msosd.c

LCD OSD 程序用於8051 開發lcd

#include <stdlib.h>
#include "types.h"
#include "board.h"
#include "ms_reg.h"
#include "panel.h"
#include "font.h"
#include "debug.h"
#include "ms_rwreg.h"
#include "mstar.h"
#include "misc.h"
#include "global.h"
#include "menudef.h"

#define OsdMsg	1
#define DoubleXSize	0
#define DoubleYSize	0

#define FontBytesNum	27
#if OsdMsg
 #define Out_i	printData
 #define Out_s	printMsg
#else
 #define Out_i
 #define Out_s
#endif


#define ColorFontStart		214

//==================================================================================
// Local function declaration
//
void mStar_WriteOSDByte(BYTE address, BYTE value);
BYTE mStar_ReadOSDByte(BYTE address);
void Osd_SetWindowSize(BYTE width, BYTE height);
void Osd_SetPosition(BYTE xPos, BYTE yPos);
void Osd_DrawChar(BYTE xPos, BYTE yPos, BYTE ch);
//void Osd_LoadFont(BYTE addr, WORD *fontPtr, BYTE num);
void Osd_LoadFont(BYTE addr, BYTE *fontPtr, WORD num);
void Osd_LoadColor(BYTE *colorPtr, BYTE num);
void Osd_LoadColorFont(BYTE addr, BYTE *fontPtr, WORD num);

//==================================================================================
// variable declaration
//
BYTE OsdWindowWidth=10;
BYTE OsdWindowHeight=10;
BYTE OsdFontColor=0x01;

//==================================================================================
// Code start
void Osd_InitOSD(void)
{ // Osd transparency control
  { BYTE retry=10;

    while (retry--)
      { mStar_WriteByte(OSDIOA, CLR_B);
        Delay1ms(3);
        if (mStar_ReadByte(OSDIOA)&CLR_B)
          mStar_ResetDClkPLL();
      }
  }
#if ChipID==ChipBB
  { mStar_WriteOSDByte(OSDDBC, 0x4); // enable double
    mStar_WriteOSDByte(OSDW, 0);
    mStar_WriteOSDByte(OSDH, 0);
    Osd_DrawChar(0, 0, 0x2);
    mStar_WriteOSDByte(IOSDC1, 0x03); //
    ForceDelay1ms(60);
    mStar_WriteOSDByte(IOSDC1, 0x00);
  }
#endif

  mStar_WriteByte(BLENDC, 0);//
  mStar_WriteByte(BLENDL, 0);//

  mStar_WriteOSDByte(OSDDBC, 0x5); // enable double
  mStar_WriteOSDByte(OCBUFO, 0x00); // disable OSD code buffer Base/Offset address
  mStar_WriteOSDByte(SUBW0C, 0x02);
  mStar_WriteOSDByte(IOSDC3, 0x00);//0x0F); // shadow function control
  mStar_WriteOSDByte(OSDHC, 0x44); // shadow width control

  mStar_WriteOSDByte(SUBW1A, (CP_WhiteColor<<4)|CP_BlueColor);
  mStar_WriteOSDByte(SUBW2A, (CP_WhiteColor<<4)|CP_BlueColor);
  mStar_WriteOSDByte(SUBW3A, (CP_CyanColor<<4)|CP_GrayColor);
  mStar_WriteOSDByte(SW1HST, 3); // for Gauge
  mStar_WriteOSDByte(SW1HEND, 24); //
  mStar_WriteOSDByte(SW2HST, OSDStartPos+4); // for Language
  mStar_WriteOSDByte(SW2HEND, 28); //

  Osd_SetWindowSize(20, 10); // set osd window
  Osd_SetPosition(50, 50); // set osd position
  Osd_LoadFont(0, &tOSDFont0, sizeof(tOSDFont0));///FontBytesNum); // load osd fonts
//  Osd_LoadColorFont(ColorFontStart, &tOSDFont1, sizeof(tOSDFont1));///54); // load osd fonts
  Osd_LoadColor(&tOSDColorPalette0, sizeof(tOSDColorPalette0));   // load osd color
  mStar_WriteOSDByte(IOSDC2, 0x02); // color bit setting
  mStar_WriteOSDByte(OSDCFA, ColorFontStart); // color font start address
}

// setup osd window size
void Osd_SetWindowSize(BYTE width, BYTE height)
{ OsdWindowWidth=width&0x3F;
  OsdWindowHeight=height&0x1F;
  mStar_WriteOSDByte(OSDW, OsdWindowWidth-1);
  mStar_WriteOSDByte(OSDH, OsdWindowHeight-1);

  mStar_WriteByte(OSDIOA, 0xDE); // clear osd content
  ForceDelay1ms(3);
  mStar_WriteByte(OSDIOA, 0x9E);
}

// setup
BYTE code OSDPos[5][2]=
{ {10, 10},
  {90, 10},
  {50, 50},
  {90, 90},
  {10, 90},
};
void Osd_SetPosition(BYTE xPos, BYTE yPos)
{ WORD posValue;
  if (xPos<5)
    { yPos=OSDPos[xPos][1];
      xPos=OSDPos[xPos][0];
    }

#if DoubleXSize
  posValue=((DWORD)xPos*(PanelWidth-(WORD)OsdWindowWidth*12*2))/100+(PanelHStart-48);
#else
  posValue=((DWORD)xPos*(PanelWidth-(WORD)OsdWindowWidth*12))/100+(PanelHStart-48);
#endif

  posValue=posValue/4;
  mStar_WriteOSDByte(OHSTA_L, posValue&0xFF);
  mStar_WriteOSDByte(OHSTA_H, posValue>>8);

#if DoubleYSize
  posValue=((DWORD)yPos*(PanelHeight-(WORD)OsdWindowHeight*18*2))/100;
#else
  posValue=((DWORD)yPos*(PanelHeight-(WORD)OsdWindowHeight*18))/100;
#endif

  posValue=posValue/4;;
  mStar_WriteOSDByte(OVSTA_L, posValue&0xFF);
  mStar_WriteOSDByte(OVSTA_H, posValue>>8);
}

#if ChipID<ChipAD || DDRBus
#define mStar_WriteDDRByte	mStar_WriteByte
#endif
void Osd_LoadFont(BYTE addr, BYTE *fontPtr, WORD num)
{
#if ChipID>=ChipAD && !DDRBus
  mStar_WriteByte(0x9F, 0x80);
#endif

  mStar_WriteDDRByte(RAMFA, addr);
  while (num--)
    mStar_WriteDDRByte(RAMFD, *(fontPtr++));

#if ChipID>=ChipAD && !DDRBus
  mStar_WriteDDRByte(0x9F, 0x00);
#endif
}
#if 0
void Osd_LoadColorFont(BYTE addr, BYTE *fontPtr, WORD num)
{ mStar_WriteByte(RAMFA, addr);
  while (num--)
    mStar_WriteByte(RAMFD, *(fontPtr++));
}
#endif
void Osd_LoadColor(BYTE *colorPtr, BYTE num)
{ mStar_WriteByte(OSDRA, CLR0R);
  mStar_WriteTBL(OSDRD, colorPtr, num, 0);
}

void Osd_SetTextColor(BYTE foreColor, BYTE backColor)
{ OsdFontColor=(foreColor&0xF)<<4|(backColor&0xF);
}

void Osd_DrawChar(BYTE xPos, BYTE yPos, BYTE ch)
{ WORD tempValue;
  BYTE drawCode=TRUE;

  if (yPos&BIT7)
    drawCode=FALSE;
  yPos&=0x3F;//~(BIT7|BIT6);

  tempValue=(WORD)yPos*OsdWindowWidth+xPos; // get real address
  mStar_WriteWord(DISPAA_H, tempValue); // display font attribute
  mStar_WriteByte(DISPAD, OsdFontColor);
  if (drawCode)
    { mStar_WriteWord(DISPCA_H, tempValue); // dispaly font code
      mStar_WriteByte(DISPCD, ASCII2FONT[ch]);
    }
}

void Osd_DrawStr(BYTE xPos, BYTE yPos, BYTE *str)
{ WORD tempValue;
  BYTE drawCode=TRUE;

  if (yPos&BIT7)
    drawCode=FALSE;
  yPos&=0x3F;//~(BIT7|BIT6);

#define dispChar	xPos
#define dispPtr		yPos

  tempValue=(WORD)yPos*OsdWindowWidth+xPos; // get real address
  dispPtr=0;
  mStar_WriteWord(DISPAA_H, tempValue);
  while (dispChar=*(str+dispPtr))  // display string font index
    { mStar_WriteByte(DISPAD, OsdFontColor);
      dispPtr++;
    }
  if (drawCode==TRUE)
    { dispPtr=0;
      mStar_WriteWord(DISPCA_H, tempValue);
      while (dispChar=*(str+dispPtr))  // display string font index
        { mStar_WriteByte(DISPCD, ASCII2FONT[dispChar]);
          dispPtr++;
        }
    }
#undef dispChar
#undef dispPtr
}

#define Num2ASCII(Num) (Num+0x30)
void DrawNum(BYTE xPos, BYTE yPos, char len, WORD value)//int value)
{ char _minus=0;

  if (value<0)
    { value=0-value;
      _minus=1;
    }
  if (value==0)
    Osd_DrawChar(xPos+(len--), yPos, (BYTE)Num2ASCII(0));
  else
    { while (value && len) // translate integer to string
        { Osd_DrawChar(xPos+(len--), yPos, (BYTE)Num2ASCII(value%10));
          value/=10;
        }
    }
  if (_minus && len>=0)// add sign
    Osd_DrawChar(xPos+(len--), yPos, (BYTE)'-');
  _minus=(_minus)?(0):(1);
  for (; _minus<=len; _minus++)
    Osd_DrawChar(xPos+_minus, yPos, (BYTE)' ');
}

void Osd_DrawNum(BYTE xPos, BYTE yPos, int value)
{ DrawNum(xPos, yPos, 3, value);
}
void Osd_Draw4Num(BYTE xPos, BYTE yPos, int value)
{ DrawNum(xPos, yPos, 5, value);
}
//===================================================================================
#define GuageFontStart	0xF0
#define GuageFontEnd	0xF1
#define GuageFont0_4	0xF2
#define GuageFont1_4	0xF3
#define GuageFont2_4	0xF4
#define GuageFont3_4	0xF5
#define GuageFont4_4	0xF6
void Osd_DrawGuage(BYTE xPos, BYTE yPos, BYTE length, BYTE value)
{ BYTE leadPtr;
  WORD tempValue;

//  Osd_DrawChar(xPos-1, yPos, '-');
//  Osd_DrawChar(xPos+length+1, yPos, '+');
  Osd_DrawChar(xPos, yPos, GuageFontStart);
  Osd_DrawChar(xPos+length-1, yPos, GuageFontEnd);

  length-=2;
  leadPtr=(WORD)value*length/10;   // resver 0.1
#define i	value
  tempValue=(WORD)yPos*OsdWindowWidth+(xPos+1); // get real address
  mStar_WriteWord(DISPAA_H, tempValue); // display font attribute
  mStar_WriteWord(DISPCA_H, tempValue); // dispaly font code

//  printData("lead %d", leadPtr);
//  printData("value %d", value);
  tempValue=leadPtr/10;
  if (tempValue==length && value<100)
    tempValue--;

//  for (i=1; i<=leadPtr/10; i++) // fill font with value
  for (i=1; i<=tempValue; i++) // fill font with value
    { mStar_WriteByte(DISPCD, ASCII2FONT[GuageFont4_4]);
      mStar_WriteByte(DISPAD, OsdFontColor);
    }

  i=i+1;
  if (i<=length) // fill font without value
    { tempValue=(WORD)yPos*OsdWindowWidth+(xPos+i); // get real address
      mStar_WriteWord(DISPAA_H, tempValue); // display font attribute
      mStar_WriteWord(DISPCA_H, tempValue); // dispaly font code
      //  for (i=leadPtr/10+2; i<=length; i++)
      for (; i<=length; i++)
        { mStar_WriteByte(DISPCD, ASCII2FONT[GuageFont0_4]);
          mStar_WriteByte(DISPAD, OsdFontColor);
     	}
    }
#undef i
  if (leadPtr<length*10)
    { value=leadPtr%10;
      xPos+=leadPtr/10+1;
      leadPtr=((WORD)value*12+5)/10;
      if (leadPtr<3 && value)
      	leadPtr=3;
      Osd_DrawChar(xPos, yPos, GuageFont0_4+leadPtr/3);
    }
}

void Osd_Show(void)
{
#if 0
  mStar_WriteByte(BLENDC, 5);
  mStar_WriteByte(BLENDL, 0x27);
  Delay1ms(20);
  mStar_WriteOSDByte(IOSDC1, 3);
  Delay1ms(20);
  mStar_WriteOSDByte(IOSDC1, 0);
//  mStar_WriteByte(BLENDL, 0x0);
  Delay1ms(20);
#endif
  mStar_WriteOSDByte(IOSDC1, (DoubleXSize<<4)|(DoubleYSize<<6)|MWIN_B);//|MWIN_B);
//  mStar_WriteByte(BLENDL, 0x0);
}
void Osd_Hide(void)
{ mStar_WriteOSDByte(IOSDC1, 0x00);
}

void mStar_WriteOSDByte(BYTE address, BYTE value)
{ mStar_WriteByte(OSDRA, address);
  mStar_WriteByte(OSDRD, value);
}
BYTE mStar_ReadOSDByte(BYTE address)
{ mStar_WriteByte(OSDRA, address);
  return mStar_ReadByte(OSDRD);
}


#if 0
// ============================
// Draw Hex for Debug
BYTE Hex2ASCII(BYTE Num)
{ return (Num<10)?(Num+0x30):(Num+0x37);
}
void DrawHex(BYTE xPos, BYTE yPos, WORD value)
{ char len=3;
//  Osd_DrawChar(xPos+4, yPos, (BYTE)'H');
  while (value && len>=0)
    { Osd_DrawChar(xPos+(len--), yPos, (BYTE)Hex2ASCII(value%0x10));
      value/=0x10;
    }
  if (len>0)
    for (value=0; value<=len; value++)
      Osd_DrawChar(xPos+value, yPos, (BYTE)'0');
}

void Osd_DrawHex(BYTE xPos, BYTE yPos, WORD value)
{ DrawHex(xPos, yPos, value);
}
#endif