vfd_tool.c

MTK1389D dvd原程序

        pbIndex += 3;
      }
      else
      {
        sprintf(pcIndex, "0x%02x, 0x%02x, 0x%02x, ",
                VFD_LIST_END, VFD_LIST_END, VFD_LIST_END);
      }
      pcIndex += 18;
    }

    /* the list end is added here */
    sprintf(pcIndex, "0x%02x", VFD_LIST_END);
    pcIndex += 4;

    /* terminate the string */
    *pcIndex = 0;

    fprintf(out,"  {%s},\n",pcTmp);
  }

  return;
}

/************************************************************************
     Function : 
  Description : 
    Parameter : 
    Return    :
************************************************************************/
void VfdWriteList(FILE *out, BYTE bNo, BYTE bListMax)
{
  BYTE i, j, bMaxLen;
  char pcTmp[MAX_LIST_LEN*6+5];
  BYTE *pbIndex;
  char *pcIndex;

  /* convert binary to string */
  pbIndex = (prShadow[bNo]).pbList;
  pcIndex = pcTmp;

  for (j=0;j<bListMax;j++)
  {
    if (j < (prShadow[i]).bListLen)
    {
      sprintf(pcIndex, "0x%02x, 0x%02x, 0x%02x, ",
              *pbIndex, *(pbIndex+1), *(pbIndex+2));
      pbIndex += 3;
    }
    else
    {
      sprintf(pcIndex, "0x%02x, 0x%02x, 0x%02x, ",
              VFD_LIST_END, VFD_LIST_END, VFD_LIST_END);
    }
    pcIndex += 18;
  }

  /* the list end is added here */
  sprintf(pcIndex, "0x%02x", VFD_LIST_END);
  pcIndex += 4;

  /* terminate the string */
  *pcIndex = 0;

  fprintf(out,"{%s}",pcTmp);

  return;
}

/************************************************************************
     Function : 
  Description : 
    Parameter :
    Return    : 
************************************************************************/
void VfdWheel(FILE *out_c, FILE *out_h)
{
  BYTE i, bPos;
  BYTE bMaxLen;

  if (sizeof(prVfdWheel) > 0)
  {
    fprintf(out_c, "#define VFD_WHEEL_FANS %d\n", VFD_WHEEL_FANS);
    fprintf(out_c, "#define VFD_WHEEL_SZ   (VFD_WHEEL_FANS + 2)\n");
    fprintf(out_c, "\n#ifdef INVERT_LITED_WHEEL\n");
  
    /* reset shadow RAM */
    vResetShadow();
  
    /* wheel all on */
    for (i=0;i<VFD_WHEEL_FANS;i++)
    {
      VfdSetIcon(&prVfdWheel[i], 1, 0);
    }
  
    /* spin wheel, INVERT */
    for (bPos=0;bPos<VFD_WHEEL_FANS;bPos++)
    {
      for (i=0;i<VFD_WHEEL_FANS;i++)
      {
        VfdSetIcon(&prVfdWheel[i], (i == bPos), bPos+1);
      }
    }
  
    /* wheel all off */
    for (i=0;i<VFD_WHEEL_FANS;i++)
    {
      VfdSetIcon(&prVfdWheel[i], 0, VFD_WHEEL_FANS+1);
    }
  
    /* get list */
    for (i=0;i<VFD_WHEEL_FANS+2;i++)
    {
      VfdGetList(i);
    }
  
    bMaxLen = bVfdGetListLenMax(VFD_WHEEL_FANS+2);
  
    fprintf(out_c, "#define VFD_WHEEL_LIST_SZ %d\n",LIST_ITEM2LEN(bMaxLen));
    fprintf(out_c, "code BYTE pbVfdWheel[VFD_WHEEL_SZ][VFD_WHEEL_LIST_SZ] = {\n");
  
    /* write list */
    VfdWriteAllList(out_c, VFD_WHEEL_FANS+2, bMaxLen);
  
    fprintf(out_c, "};\n");
    fprintf(out_c, "#else\n");
  
    /* reset shadow RAM */
    vResetShadow();
  
    /* wheel all on */
    for (i=0;i<VFD_WHEEL_FANS;i++)
    {
      VfdSetIcon(&prVfdWheel[i], 1, 0);
    }
  
    /* spin wheel, normal */
    for (bPos=0;bPos<VFD_WHEEL_FANS;bPos++)
    {
      for (i=0;i<VFD_WHEEL_FANS;i++)
      {
        VfdSetIcon(&prVfdWheel[i], (i != bPos), bPos+1);
      }
    }
  
    /* wheel all off */
    for (i=0;i<VFD_WHEEL_FANS;i++)
    {
      VfdSetIcon(&prVfdWheel[i], 0, VFD_WHEEL_FANS+1);
    }
  
      /* get list */
    for (i=0;i<VFD_WHEEL_FANS+2;i++)
    {
      VfdGetList(i);
    }
  
    bMaxLen = bVfdGetListLenMax(VFD_WHEEL_FANS+2);
  
    fprintf(out_c, "#define VFD_WHEEL_LIST_SZ %d\n",LIST_ITEM2LEN(bMaxLen));
    fprintf(out_c, "code BYTE pbVfdWheel[VFD_WHEEL_SZ][VFD_WHEEL_LIST_SZ] = {\n");
  
    /* write list */
    VfdWriteAllList(out_c, VFD_WHEEL_FANS+2, bMaxLen);
  
    fprintf(out_c, "};\n");
    fprintf(out_c, "#endif\n");
  }
  else /* sizeof(prVfdWheel) == 0 */
  {
    fprintf(out_c, "#define VFD_WHEEL_FANS 0\n");
    fprintf(out_c, "#define VFD_WHEEL_SZ   0\n");
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdSetChar(WORD *pwSeg, WORD wCode, BYTE bNo)
{
  BYTE i;

  for (i = 0; i < VFD_CHAR_SEG_SZ; i++)
  {
    if (!IS_NODE_EMPTY(pwSeg[i]))
    {
      VfdSetIcon((strucVfdIcon *)(pwSeg+i), wCode & 1, bNo);
    }
    wCode >>= 1;
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdClearChar(WORD *pwSeg, WORD wCode, BYTE bNo)
{
  BYTE i;

  for (i = 0; i < VFD_CHAR_SEG_SZ; i++)
  {
    if (!IS_NODE_EMPTY(pwSeg[i]))
    {
      VfdSetIcon((strucVfdIcon *)(pwSeg+i), 0, bNo);
    }
    wCode >>= 1;
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdMsgCompose(WORD *pwMsg, BYTE bNo)
{
  BYTE *pbMsgPos = pbVfdMsgPosition;  /* Display order */
  strucVfdSegment *prPtr;  /* 8 segment for corresponding character */

  while (*pwMsg != CHAR_end)
  {
    /* Get the 8 segments for the corresponding character position  */
    prPtr = &prVfdCharSegments[*pbMsgPos++];
    VfdSetChar(prPtr->pwSeg, *pwMsg, bNo);
    pwMsg++;
  }
}

/************************************************************************
     Function :
  Description : 
    Parameter :
    Return    :
************************************************************************/
void VfdMsg(FILE *out_c, FILE *out_h)
{
  BYTE i, bMaxLen;

  fprintf(out_c, "\n#define VFD_CHAR_NO %d\n", VFD_CHAR_NO);
  fprintf(out_c, "#define VFD_MSG_NO %d\n", VFD_MSG_NO);
  fprintf(out_c, "#define VFD_CHAR_SEG_SZ %d\n\n", VFD_CHAR_SEG_SZ);
  /* fprintf(out, "#define VFD_MSG_CHAR_NUM %d\n\n", VFD_MSG_CHAR_NUM); */

  /* reset shadow RAM */
  vResetShadow();

  /* check max message number */
  assert(VFD_MSG_NO <= MAX_SHADOW_NUMBER);

  /* compose message first */
  for (i=0;i<VFD_MSG_NO;i++)
  {
    VfdMsgCompose(prVfdMsg[i].pwMsg,i);
  }

  /* get list */
  for (i=0;i<VFD_MSG_NO;i++)
  {
    VfdGetList(i);
  }

  bMaxLen = bVfdGetListLenMax(VFD_MSG_NO);

  fprintf(out_c, "code BYTE pbVfdMsg[][%d] = {\n", LIST_ITEM2LEN(bMaxLen));
  VfdWriteAllList(out_c, VFD_MSG_NO, bMaxLen);
  fprintf(out_c, "};\n");

  for (i=0;i<VFD_MSG_NO;i++)
  {
    fprintf(out_h,"#define VFDMSG_%s    %d\n", prVfdMsg[i].pcName, i);
  }
}

/************************************************************************
     Function :
  Description : 
    Parameter : 
    Return    :
************************************************************************/
void VfdWriteFieldDefine(FILE *out)
{
  fprintf(out, "#define VFD_TRACK      %d\n", VFD_TRACK);
  fprintf(out, "#define VFD_CHAPTER    %d\n", VFD_TRACK);
  fprintf(out, "#define VFD_MINUTE     %d\n", VFD_MINUTE);
  fprintf(out, "#define VFD_SECOND     %d\n", VFD_SECOND);
  fprintf(out, "#define VFD_HOUR       %d\n", VFD_MIN100);
  fprintf(out, "#define VFD_MIN100     %d\n", VFD_MIN100);
  fprintf(out, "#define VFD_TITLE      %d\n", VFD_TITLE);
#if (VFD_FIELD_MAX == 10)
  fprintf(out, "#define VFD_CHAP100    %d\n", VFD_CHAP100);
#endif
  fprintf(out, "#define VFD_FIELD_MAX  %d\n", VFD_FIELD_MAX);
}

/************************************************************************
     Function :
  Description : 
    Parameter : 
    Return    :
************************************************************************/
void VfdNum(FILE *out_c, FILE *out_h)
{
  BYTE i, bPos;
  BYTE bMaxLen;

  VfdWriteFieldDefine(out_c);
  VfdWriteFieldDefine(out_h);

  fprintf(out_c, "\n#define CHAR_NUM_ARRAY_SZ %d\n\n", CHAR_NUM_ARRAY_SZ);

  for (i=0;i<10;i++)
  {
    fprintf(out_c, "#define CHAR_%d %d\n", i, i);
    fprintf(out_h, "#define CHAR_%d %d\n", i, i);
  }
  fprintf(out_c, "#define CHAR_CLEAR %d\n\n", i);
  fprintf(out_h, "#define CHAR_CLEAR %d\n\n", i);

  /* geerate number array for every char */
  for (bPos=0;bPos<VFD_CHAR_NO;bPos++)
  {
    /* reset shadow RAM */
    vResetShadow();

    /* set all numbers */
    for (i=0;i<CHAR_NUM_ARRAY_SZ-1;i++)
    {
      VfdSetChar((WORD *)(&(prVfdCharSegments[bPos])), pwNumberList[i], i);
    }

    /* the last one is CHAR_clear */
    VfdClearChar((WORD *)(&(prVfdCharSegments[bPos])), pwNumberList[i], i);

    /* get list */
    for (i=0;i<CHAR_NUM_ARRAY_SZ;i++)
    {
      VfdGetList(i);
    }

    bMaxLen = bVfdGetListLenMax(CHAR_NUM_ARRAY_SZ);

    /* write list */
    fprintf(out_c, "code BYTE pbVfdCharNo%d[CHAR_NUM_ARRAY_SZ][%d] = {\n", bPos, LIST_ITEM2LEN(bMaxLen));
    VfdWriteAllList(out_c, CHAR_NUM_ARRAY_SZ, bMaxLen);
    fprintf(out_c, "};\n\n");
  }

  fprintf(out_c, "code BYTE code * ppbVfdCharNum[VFD_CHAR_NO][CHAR_NUM_ARRAY_SZ] = {\n");
  for (i=0;i<VFD_CHAR_NO;i++)
  {
    fprintf(out_c, "  { ", i);
    for (bPos=0;bPos<CHAR_NUM_ARRAY_SZ;bPos++)
    {
      fprintf(out_c, "pbVfdCharNo%d[%d]", i, bPos);
      if (bPos == (CHAR_NUM_ARRAY_SZ-1))
      {
        fprintf(out_c, " ");
      }
      else
      {
        fprintf(out_c, ", ");
      }
      if (bPos == ((int)(CHAR_NUM_ARRAY_SZ/2)))
      {
        fprintf(out_c, "\n    ");