diag.c

ADI公司的关于光通讯模块的监控程序,在KEIL FOR ARM 的编译环境编译.程序大小约12K,芯片是ADu7020.

// diag.c

/********************************************************************/
/*                                                                  */
/*      Diagnostic routines                                         */
/*                                                                  */
/********************************************************************/
#include <ADuC7020.h>
#include "common.h"

void diag(void){
    temp_diag(A2h[96], A2h[97], 0);
    voltage_diag(A2h[98], A2h[99], 8);
    tx_bias_diag(A2h[100], A2h[101], 16);
    tx_power_diag(A2h[102], A2h[103], 24);
    rx_power_diag(A2h[104], A2h[105], 32);
    check_los_ratesel();
}

/********************************************************************/
/*                                                                  */
/*      Temperature Diagnostic routine                              */
/*                                                                  */
/********************************************************************/
void temp_diag(BYTE msb, BYTE lsb, BYTE addr){

    // Temperature diag. parameters located from address 0
    BYTE result;
    HALFWORD monitor = (msb<<8) + lsb;
    HALFWORD high_alarm =	(A2h[addr  ]<<8) + A2h[addr+1];
    HALFWORD low_alarm =	(A2h[addr+2]<<8) + A2h[addr+3];
    HALFWORD high_warning =	(A2h[addr+4]<<8) + A2h[addr+5];
    HALFWORD low_warning =	(A2h[addr+6]<<8) + A2h[addr+7];

    if (monitor>high_alarm) result=5;
    else if (monitor>high_warning && monitor<=high_alarm) result=4;
    else if (monitor<=high_warning && monitor>=low_warning) result=3;
    else if (monitor<low_warning && monitor>= low_alarm) result=2;
    else result=1;

    switch (result)
    {
        case 5:
			A2h[112] |= 0x80;		// set high alarm flag bit7
			A2h[116] |= 0x80;		// set high warning flag bit7
			A2h[116] &= 0xBF;		// clear low warning flag bit6
			A2h[112] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 4:
			A2h[112] &= 0x7F;		// clear high alarm flag bit7
			A2h[116] |= 0x80;		// set high warning flag bit7
			A2h[116] &= 0xBF;		// clear low warning flag bit6
			A2h[112] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 3:
			A2h[112] &= 0x7F;		// clear high alarm flag bit7
			A2h[116] &= 0x7F;		// clear high warning flag bit7
			A2h[116] &= 0xBF;		// clear low warning flag bit6
			A2h[112] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 2:
			A2h[112] &= 0x7F;		// clear high alarm flag bit7
			A2h[116] &= 0x7F;		// clear high warning flag bit7
			A2h[116] |= 0x40;		// set low warning flag bit6
			A2h[112] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 1:
			A2h[112] &= 0x7F;		// clear high alarm flag bit7
			A2h[116] &= 0x7F;		// clear high warning flag bit7
			A2h[116] |= 0x40;		// set low warning flag bit6
			A2h[112] |= 0x40;		// set low alarm flag bit6
			break;
	}
}

/********************************************************************/
/*                                                                  */
/*      Voltage Diagnostic routine                                  */
/*                                                                  */
/********************************************************************/
void voltage_diag(BYTE msb, BYTE lsb, BYTE addr){

    BYTE result;
    HALFWORD monitor = (msb<<8) + lsb;
    HALFWORD high_alarm =   (A2h[addr  ]<<8) + A2h[addr+1];
    HALFWORD low_alarm =    (A2h[addr+2]<<8) + A2h[addr+3];
    HALFWORD high_warning =	(A2h[addr+4]<<8) + A2h[addr+5];
    HALFWORD low_warning =  (A2h[addr+6]<<8) + A2h[addr+7];

    if (monitor>high_alarm) result=5;
    else if (monitor>high_warning && monitor<=high_alarm) result=4;
    else if (monitor<=high_warning && monitor>=low_warning) result=3;
    else if (monitor<low_warning && monitor>= low_alarm) result=2;
    else result=1;

    switch (result)
    {
		case 5:
			A2h[112] |= 0x20;		// set high alarm flag bit5
			A2h[116] |= 0x20;		// set high warning flag bit5
			A2h[116] &= 0xEF;		// clear low warning flag bit4
			A2h[112] &= 0xEF;		// clear low alarm flag bit4
			break;
		case 4:
			A2h[112] &= 0xDF;		// clear high alarm flag bit5
			A2h[116] |= 0x20;		// set high warning flag bit5
			A2h[116] &= 0xEF;		// clear low warning flag bit4
			A2h[112] &= 0xEF;		// clear low alarm flag bit4
			break;
		case 3:
			A2h[112] &= 0xDF;		// clear high alarm flag bit5
			A2h[116] &= 0xDF;		// clear high warning flag bit5
			A2h[116] &= 0xEF;		// clear low warning flag bit4
			A2h[112] &= 0xEF;		// clear low alarm flag bit4
			break;
		case 2:
			A2h[112] &= 0xDF;		// clear high alarm flag bit5
			A2h[116] &= 0xDF;		// clear high warning flag bit5
			A2h[116] |= 0x10;		// set low warning flag bit4
			A2h[112] &= 0xEF;		// clear low alarm flag bit4
			break;
		case 1:
			A2h[112] &= 0xDF;		// clear high alarm flag bit5
			A2h[116] &= 0xDF;		// clear high warning flag bit5
			A2h[116] |= 0x10;		// set low warning flag bit4
			A2h[112] |= 0x10;		// set low alarm flag bit4
			break;
	}
}

/********************************************************************/
/*                                                                  */
/*      TX Bias Diagnostic routine                                  */
/*                                                                  */
/********************************************************************/
void tx_bias_diag(BYTE msb, BYTE lsb, BYTE addr){

    BYTE result;
    HALFWORD monitor = (msb<<8) + lsb;
    HALFWORD high_alarm =   (A2h[addr  ]<<8) + A2h[addr+1];
    HALFWORD low_alarm =    (A2h[addr+2]<<8) + A2h[addr+3];
    HALFWORD high_warning = (A2h[addr+4]<<8) + A2h[addr+5];
    HALFWORD low_warning =  (A2h[addr+6]<<8) + A2h[addr+7];

    if (monitor>high_alarm) result=5;
    else if (monitor>high_warning && monitor<=high_alarm) result=4;
    else if (monitor<=high_warning && monitor>=low_warning) result=3;
    else if (monitor<low_warning && monitor>= low_alarm) result=2;
    else result=1;

    switch (result)
    {
		case 5:
			A2h[112] |= 0x08;		// set high alarm flag bit3
			A2h[116] |= 0x08;		// set high warning flag bit3
			A2h[116] &= 0xFB;		// clear low warning flag bit2
			A2h[112] &= 0xFB;		// clear low alarm flag bit2
			break;
		case 4:
			A2h[112] &= 0xF7;		// clear high alarm flag bit3
			A2h[116] |= 0x08;		// set high warning flag bit3
			A2h[116] &= 0xFB;		// clear low warning flag bit2
			A2h[112] &= 0xFB;		// clear low alarm flag bit2
			break;
		case 3:
			A2h[112] &= 0xF7;		// clear high alarm flag bit3
			A2h[116] &= 0xF7;		// clear high warning flag bit3
			A2h[116] &= 0xFB;		// clear low warning flag bit2
			A2h[112] &= 0xFB;		// clear low alarm flag bit2
			break;
		case 2:
			A2h[112] &= 0xF7;		// clear high alarm flag bit3
			A2h[116] &= 0xF7;		// clear high warning flag bit3
			A2h[116] |= 0x04;		// set low warning flag bit2
			A2h[112] &= 0xFB;		// clear low alarm flag bit2
			break;
		case 1:
			A2h[112] &= 0xF7;		// clear high alarm flag bit3
			A2h[116] &= 0xF7;		// clear high warning flag bit3
			A2h[116] |= 0x04;		// set low warning flag bit2
			A2h[112] |= 0x04;		// set low alarm flag bit2
			break;
	}
}

/********************************************************************/
/*                                                                  */
/*      TX Power Diagnostic routine                                 */
/*                                                                  */
/********************************************************************/
void tx_power_diag(BYTE msb, BYTE lsb, BYTE addr){

    BYTE result;
    HALFWORD monitor = (msb<<8) + lsb;
    HALFWORD high_alarm =   (A2h[addr  ]<<8) + A2h[addr+1];
    HALFWORD low_alarm =    (A2h[addr+2]<<8) + A2h[addr+3];
    HALFWORD high_warning = (A2h[addr+4]<<8) + A2h[addr+5];
    HALFWORD low_warning =  (A2h[addr+6]<<8) + A2h[addr+7];

    if (monitor>high_alarm) result=5;
    else if (monitor>high_warning && monitor<=high_alarm) result=4;
    else if (monitor<=high_warning && monitor>=low_warning) result=3;
    else if (monitor<low_warning && monitor>= low_alarm) result=2;
    else result=1;

    switch (result)
    {
		case 5:
			A2h[112] |= 0x02;		// set high alarm flag bit1
			A2h[116] |= 0x02;		// set high warning flag bit1
			A2h[116] &= 0xFE;		// clear low warning flag bit0
			A2h[112] &= 0xFE;		// clear low alarm flag bit0
			break;
		case 4:
			A2h[112] &= 0xFD;		// clear high alarm flag bit1
			A2h[116] |= 0x02;		// set high warning flag bit1
			A2h[116] &= 0xFE;		// clear low warning flag bit0
			A2h[112] &= 0xFE;		// clear low alarm flag bit0
			break;
		case 3:
			A2h[112] &= 0xFD;		// clear high alarm flag bit1
			A2h[116] &= 0xFD;		// clear high warning flag bit1
			A2h[116] &= 0xFE;		// clear low warning flag bit0
			A2h[112] &= 0xFE;		// clear low alarm flag bit0
			break;
		case 2:
			A2h[112] &= 0xFD;		// clear high alarm flag bit1
			A2h[116] &= 0xFD;		// clear high warning flag bit1
			A2h[116] |= 0x01;		// set low warning flag bit0
			A2h[112] &= 0xFE;		// clear low alarm flag bit0
			break;
		case 1:
			A2h[112] &= 0xFD;		// clear high alarm flag bit1
			A2h[116] &= 0xFD;		// clear high warning flag bit1
			A2h[116] |= 0x01;		// set low warning flag bit0
			A2h[112] |= 0x01;		// set low alarm flag bit0
			break;
    }
}

/********************************************************************/
/*                                                                  */
/*      Rx Power Diagnostic routine                                 */
/*                                                                  */
/********************************************************************/
void rx_power_diag(BYTE msb, BYTE lsb, BYTE addr){

    BYTE result;
    HALFWORD monitor = (msb<<8) + lsb;
    HALFWORD high_alarm =   (A2h[addr  ]<<8) + A2h[addr+1];
    HALFWORD low_alarm =    (A2h[addr+2]<<8) + A2h[addr+3];
    HALFWORD high_warning = (A2h[addr+4]<<8) + A2h[addr+5];
    HALFWORD low_warning =  (A2h[addr+6]<<8) + A2h[addr+7];

    if (monitor>high_alarm) result=5;
    else if (monitor>high_warning && monitor<=high_alarm) result=4;
    else if (monitor<=high_warning && monitor>=low_warning) result=3;
    else if (monitor<low_warning && monitor>= low_alarm) result=2;
    else result=1;

    switch (result)
    {
		case 5:
			A2h[113] |= 0x80;		// set high alarm flag bit7
			A2h[117] |= 0x80;		// set high warning flag bit7
			A2h[117] &= 0xBF;		// clear low warning flag bit6
			A2h[113] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 4:
			A2h[113] &= 0x7F;		// clear high alarm flag bit7
			A2h[117] |= 0x80;		// set high warning flag bit7
			A2h[117] &= 0xBF;		// clear low warning flag bit6
			A2h[113] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 3:
			A2h[113] &= 0x7F;		// clear high alarm flag bit7
			A2h[117] &= 0x7F;		// clear high warning flag bit7
			A2h[117] &= 0xBF;		// clear low warning flag bit6
			A2h[113] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 2:
			A2h[113] &= 0x7F;		// clear high alarm flag bit7
			A2h[117] &= 0x7F;		// clear high warning flag bit7
			A2h[117] |= 0x40;		// set low warning flag bit6
			A2h[113] &= 0xBF;		// clear low alarm flag bit6
			break;
		case 1:
			A2h[113] &= 0x7F;		// clear high alarm flag bit7
			A2h[117] &= 0x7F;		// clear high warning flag bit7
			A2h[117] |= 0x40;		// set low warning flag bit6
			A2h[113] |= 0x40;		// set low alarm flag bit6
			break;
	}
}


/********************************************************************/
/*                                                                  */
/*      Check fault recovery status                                 */
/*                                                                  */
/********************************************************************/
void fault_recovery_check(void){

        // latch Tx Laser Fault condition
        if (!(GP0DAT & 0x00000010))     // check if Laser fault recovered   
        {
            IRQEN |= 0x00008000;        // enable XIRQ0 again
            A2h[110] &= 0xFB;           // clear bit2
        }

        // latch Tx Laser disable state
        if (!(GP0DAT & 0x00000020))     // check if Laser disable recovered   
        {
            IRQEN |= 0x00040000;        // enable XIRQ1 again
            A2h[110] &= 0x7F;           // clear bit7
        }

/*
        // latch Rx LOS
        if (!(GP1DAT & 0x00000010))     // check if LOS recovered   
        {
            IRQEN |= 0x00080000;        // enable PLAIRQ0 again
            A2h[110] &= 0xFD;           // clear bit1
        }

        // latch Rx Rate Sel
        if (!(GP1DAT & 0x00000020))     // check if Rate Sel is LOW state   
        {
            IRQEN |= 0x00100000;        // enable PLAIRQ1 again
            A2h[110] &= 0xEF;           // clear bit4
        }
*/
}

/********************************************************************/
/*                                                                  */
/*      Check LOS and RateSel bits                                  */
/*                                                                  */
/********************************************************************/
void check_los_ratesel(void){

    // LOS P1.4
    if((GP1DAT & 0x00000010)) A2h[110] |= 0x02;    // set bit1(LOS)
    else A2h[110] &= 0xFD;                        // clear bit1
    
    // RateSel P1.5
    if((GP1DAT & 0x00000020)) A2h[110] |= 0x10;    // set bit4(RateSel)
    else A2h[110] &= 0xEF;           // clear bit4 

}