mc141585.c

MC141585编程应用

/* FUNCTION:    osd_SetDataAttr(BYTE B_Row, BYTE B_Column, 					*/
/*								BYTE B_Data,BYTE B_Length) 					*/
/*																			*/
/* USAGE:       Set the display data attribute to the input value           */
/*																			*/
/* INPUT:       B_Row    - character attribute register row number          */
/*              B_Column - start column                                     */
/*              B_Data   - attribute data                                   */
/*						   character color, background color and blinking	*/
/*                         (C_BLINK, BG_TRANSP...BG_WHITE, BLACK...WHITE)   */
/*              B_Length - number of byte to set                            */
/*																			*/
/* OUTPUT:      OK - sucessful                                              */
/*              ERR_PARAM - row or column number error						*/
/*																			*/
/****************************************************************************/
BYTE osd_SetDataAttr(BYTE B_Row,BYTE B_Column,BYTE B_Data,BYTE B_Length)
{
    BYTE Ba_Buf[MAX_BUF];
	BYTE B_Idx;

    if ((B_Row >= MAX_OSD_ROW) || (B_Column+B_Length) > MAX_OSD_COL)
	{										// Over limit ?
        return (ERR_PARAM);                 // Yes, exit
	}
	for (B_Idx=0; B_Idx<MAX_BUF; B_Idx++)	// Fill buffer with attribute value
		Ba_Buf[B_Idx] = B_Data;				//

    while (B_Length)						// Send to specify data attribute
    {
        if (B_Length > MAX_BUF)				// More than buffer size			
        {
            osd_SendFmtC(B_Row | CTRL_REG, B_Column, Ba_Buf, MAX_BUF);
            B_Column += MAX_BUF;			// Adjust column number
            B_Length -= MAX_BUF;			// Adjust length
        }
        else
        {
            osd_SendFmtC(B_Row | CTRL_REG, B_Column, Ba_Buf, B_Length);
            B_Length = 0;					// Zero length
        }
    }
    return (OK);
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    BYTE osd_Fading(BYTE B_Flag)								*/
/*																			*/
/* USAGE:       Enable or disable the OSD fade-in and fade-out				*/
/*																			*/
/* INPUT:       B_Flag - ENABLE or DISABLE									*/
/*																			*/
/* OUTPUT:      OK - sucessful                                              */
/*																			*/
/****************************************************************************/
BYTE osd_Fading(BYTE B_Flag)
{
    if (B_Flag == ENABLE)                 	// Enable fading
		B_FrameControl15 |= BIT1;			// Set bit
    else
		B_FrameControl15 &= (~BIT1);		// Clear bit
											//
	osd_SendCtrl(15, 15, B_FrameControl15);	// Frame control register
    return (OK);
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    BYTE osd_ShadowBorder(BYTE B_Flag)							*/
/*																			*/
/* USAGE:       Enable or disable the character shadow or border            */
/*																			*/
/* INPUT:       B_Flag - ENABLE_SHADOW 										*/
/*                       ENABLE_BORDER                                      */
/*                       DISABLE                                            */
/*																			*/
/* OUTPUT:      OK - sucessful                                              */
/*																			*/
/****************************************************************************/
BYTE osd_ShadowBorder(BYTE B_Flag)
{
    if (B_Flag == ENABLE_SHADOW || B_Flag == ENABLE_BORDER)
	{
        B_FrameControl15 &= ~(BIT5 | BIT6);	// Clear bit5 & bit6
        B_FrameControl15 |= B_Flag;       	// Set flag
	}
    else if (B_Flag == DISABLE)
        B_FrameControl15 &= ~(BIT5 | BIT6);	// Clear bit5 & bit6 for disable
    else
        return (ERR_PARAM);             	// Error
											//
	osd_SendCtrl(15, 15, B_FrameControl15);	// Frame control register
    return (OK);
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    BYTE osd_RowSpace(BYTE B_Line)                              */
/*																			*/
/* USAGE:       Set the row to row spacing in unit of horizontal            */
/*              scan lines.                                                 */
/*																			*/
/* INPUT:       line - row to row spacing (0 - 31)                          */
/*																			*/
/* OUTPUT:      OK        - sucessful                                       */
/*              ERR_PARAM - input parameter error                           */
/*																			*/
/****************************************************************************/
BYTE osd_RowSpace(BYTE B_Line)
{
    if (B_Line > 31)						// Over limit ?
        return (ERR_PARAM);                 // Yes, Error
                                            //
	B_FrameControl18 &= 0x07;				// Clear current setting
	B_FrameControl18 |= (B_Line << 3);		// Setup row spacing
											//
	osd_SendCtrl(15, 18, B_FrameControl18);	// Frame control register
    return (OK);
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    BYTE osd_CharSize(BYTE B_Line)								*/
/*																			*/
/* USAGE:       Set the charater size in display line.						*/
/*																			*/
/* INPUT:       B_Line - number of lines per character (16 - 63)			*/
/*																			*/
/* OUTPUT:      OK        - sucessful                                       */
/*              ERR_PARAM - input parameter error                           */
/*																			*/
/****************************************************************************/
BYTE osd_CharSize(BYTE B_Line)
{
    if (B_Line < 16 || B_Line > 63)			// Within limit ?
        return (ERR_PARAM);                 // No, error
											//
    osd_SendCtrl(15, 14, B_Line);			// Set character size
    return (OK);
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    BYTE osd_PageSelect (BYTE B_BankB, BYTE B_BankC)			*/
/*																			*/
/* USAGE:       Set character ROM mapping - Map physical ROM pages to		*/
/*				logical ROM banks B and C.									*/
/*																			*/
/* INPUT:       B_BankB - Bank B setting (1-6)								*/
/*				B_BankC - Bank C setting (1-6)								*/
/*																			*/
/* OUTPUT:      OK        - sucessful                                       */
/*              ERR_PARAM - input parameter error                           */
/*																			*/
/****************************************************************************/
BYTE osd_PageSelect (BYTE B_BankB, BYTE B_BankC)
{
	if (B_BankB < 1 || B_BankB > 6)
		return (ERR_PARAM);
	if (B_BankC < 1 || B_BankC > 6)
		return (ERR_PARAM);

    osd_SendCtrl(16, 4, ((B_BankC-1) << 4) | (B_BankB-1));
    return (OK);
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    osd_SetRegister(BYTE B_Row, BYTE B_Column, BYTE B_Data)		*/
/*																			*/
/* USAGE:       Set any register attribute in a specific row & column.      */
/*																			*/
/* INPUT:       B_Row    - register row number (0-16)      					*/
/*              B_Column - register column start number (0-30)				*/
/*              B_Data   - register value                           		*/
/*																			*/
/* OUTPUT:      OK - sucessful                                              */
/*              ERR_PARAM - error in parameters                             */
/*																			*/
/****************************************************************************/
BYTE osd_SetRegister(BYTE B_Row, BYTE B_Column, BYTE B_Data)
{
    if (B_Column > MAX_OSD_COL)                 // Over limit ?
        return (ERR_PARAM);                     // Yes, exit
                                                //
	if (B_Row == 15 || B_Column == 15)
		B_FrameControl15 = B_Data;				// Save new reigster value
	else if (B_Row == 15 || B_Column == 18)
		B_FrameControl18 = B_Data;				// Save new reigster value
	else if (B_Row == 16 || B_Column == 0)
		B_SpecialControl = B_Data;				// Save new reigster value

    osd_SendCtrl(B_Row, B_Column, B_Data);		// Send data
    return (OK);
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    void osd_SendCtrl(BYTE B_Row, BYTE B_Col, BYTE B_Data)		*/
/*																			*/
/* USAGE:       Send a single register to Control Register.                 */
/*																			*/
/* INPUT:       B_Row  - row number for register                            */
/*              B_Col  - column number for register                         */
/*              B_Data - value of the register                              */
/*																			*/
/* OUTPUT:		None														*/
/*																			*/
/****************************************************************************/
void osd_SendCtrl(BYTE B_Row, BYTE B_Col, BYTE B_Data)
{
    i2c_Start(OSD_DEV);			       		// I2C Start, Wait while device is busy
    i2c_SendByte(B_Row | CTRL_REG);   		// Control register row
    i2c_SendByte(B_Col);              		// Register column number
    i2c_SendByte(B_Data);            		// Send I2C data to the device
    i2c_Stop();                         	// I2C Stop
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    void osd_SendfmtC (BYTE B_Row, BYTE B_Col, 					*/
/*					 	  		   BYTE *Bp_Buf, BYTE B_Len)            	*/
/*																			*/
/* USAGE:       Write data to the OSD chip through I2C bus with format "C".	*/
/*																			*/
/* INPUT:       B_Row  - OSD row number										*/
/*              B_Col  - OSD column number									*/
/*              Bp_Buf - Buffer with transmitting data						*/
/*              B_Len  - Number of bytes want to write						*/
/*																			*/
/* OUTPUT:		None														*/
/*																			*/
/****************************************************************************/
void osd_SendFmtC(BYTE B_Row, BYTE B_Col, BYTE *Bp_Buf, BYTE B_Len)
{
    BYTE B_Idx;
    
	i2c_Start(OSD_DEV);						// I2C Start, Wait while device is busy
	i2c_SendByte(B_Row);					// Send row number
	i2c_SendByte(B_Col | FMT_C);			// Send column number
	for (B_Idx=0; B_Idx<B_Len; B_Idx++) 	//
		i2c_SendByte(Bp_Buf[B_Idx]);   		// Send I2C data to the device
	i2c_Stop();                         	// I2C Stop
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    void osd_SendRepFmtC(BYTE B_Row, BYTE B_Col,				*/
/*									 BYTE B_Data, BYTE B_Len)				*/
/*																			*/
/* USAGE:       Write repeated data to the OSD chip through I2C bus with	*/
/*				format "C".													*/
/*																			*/
/* INPUT:       B_Row  - OSD row number										*/
/*              B_Col  - OSD column number									*/
/*              B_Data - data to repeatedly send							*/
/*              B_Len  - Number of bytes want to write						*/
/*																			*/
/* OUTPUT:		None														*/
/*																			*/
/****************************************************************************/
void osd_SendRepFmtC(BYTE B_Row, BYTE B_Col, BYTE B_Data, BYTE B_Len)
{
	i2c_Start(OSD_DEV);						// I2C Start, Wait while device is busy
	i2c_SendByte(B_Row);					// Send row number
	i2c_SendByte(B_Col | FMT_C);			// Send column number
	while (B_Len--) 						//
		i2c_SendByte(B_Data);   			// Send I2C data to the device
	i2c_Stop();                         	// I2C Stop
}

/****************************************************************************/
/*																			*/
/* FUNCTION:    osd_DummyCall(void)                                       	*/
/*																			*/
/* USAGE:       To get by the data overlay problem when function is not     */
/*				being called.												*/
/*																			*/
/****************************************************************************/
void osd_DummyCall (void)
{
	osd_OpenWindow(0);
	osd_CloseWindow(0);
	osd_SetRowAttr(0,0);
	osd_DisplayOneIcon (0,0,0);
	osd_SetRegister(0,0,0);
	osd_ShadowBorder(0);
}

/********************************  END  *************************************/