c_ui.c

乐高机器人的源码,开发平台是IAR_for_AVR.

}


void      cUiListLeft(UBYTE Limit,UBYTE *Center)
{
  UBYTE   Tmp;

  Tmp = *Center;
  if (Tmp > 1)
  {
    Tmp--;
  }
  else
  {
    if (Limit > 2)
    {
      Tmp = Limit;
    }
  }
  *Center = Tmp;
}


void      cUiListRight(UBYTE Limit,UBYTE *Center)
{
  UBYTE   Tmp;

  Tmp = *Center;
  if (Tmp < Limit)
  {
    Tmp++;
  }
  else
  {
    if (Limit > 2)
    {
      Tmp = 1;
    }
  }
  *Center = Tmp;
}


void      cUiListCalc(UBYTE Limit,UBYTE *Center,UBYTE *Left,UBYTE *Right)
{
  switch (Limit)
  {
    case 1 :
    {
      *Left   = 0;
      *Right  = 0;
    }
    break;

    case 2 :
    {
      if ((*Center) == 1)
      {
        *Left  = 0;
        *Right = 2;
      }
      else
      {
        *Left  = 1;
        *Right = 0;
      }
    }
    break;

    default :
    {
      *Left = *Center - 1;
      if ((*Left) < 1)
      {
        *Left = Limit;
      }
      *Right = *Center + 1;
      if ((*Right) > Limit)
      {
        *Right = 1;
      }
    }
    break;
    
  }
}


UBYTE*    cUiGetMenuPointer(UBYTE FileNo) 
{
  ULONG   Lng;
  UWORD   Handle;
  UBYTE   TmpBuffer[FILENAME_LENGTH + 1];
  UBYTE   *pPointer;

  if (FileNo)
  {
    sprintf((char*)TmpBuffer,"Submenu%02X.rms",(UWORD)FileNo);
  }
  else
  {
    sprintf((char*)TmpBuffer,"Mainmenu.rms");
  }
  Handle = cUiMenuFile(OPENREADLINEAR,TmpBuffer,(UBYTE*)&pPointer,&Lng);
  if ((Handle & 0x8000))
  {
    pPointer = NULL;
  }
  else
  {
    cUiMenuFile(CLOSE,(UBYTE*)&Handle,NULL,NULL);
  }

  return (pPointer);
}


ULONG     cUiMenuGetId(MENUITEM *pMenuItem)
{
  ULONG   MenuId;

  MenuId  = (ULONG)pMenuItem->ItemId01;
  MenuId |= (ULONG)pMenuItem->ItemId23 << 8;
  MenuId |= (ULONG)pMenuItem->ItemId45 << 16;
  MenuId |= (ULONG)pMenuItem->ItemId67 << 24;

  return (MenuId);
}


ULONG     cUiMenuGetSpecialMask(MENUITEM *pMenuItem)
{
  ULONG   Mask;

  Mask = 0;
  if (pMenuItem != NULL)
  {
    Mask  = (ULONG)pMenuItem->SpecialMask0;
    Mask |= (ULONG)pMenuItem->SpecialMask1 << 8;
    Mask |= (ULONG)pMenuItem->SpecialMask2 << 16;
    Mask |= (ULONG)pMenuItem->SpecialMask3 << 24;
  }

  return (Mask);
}


UBYTE*    cUiMenuGetIconImage(UBYTE No)
{
  UBYTE   *Image;

  Image = NULL;
  if (No < (Icons->ItemsX * Icons->ItemsY))
  {
    Image = (UBYTE*)&Icons->Data[No * Icons->ItemPixelsX * (Icons->ItemPixelsY / 8)];
  }

  return (Image);
}


ULONG     cUiMenuMotherId(ULONG Id,UBYTE Level)
{
  ULONG   MotherIdMask;

  MotherIdMask  = 0xFFFFFFFFL >> ((8 - Level) * 4);
  MotherIdMask |= 0xFFFFFFFFL << ((Level + 1) * 4);

  return (Id & MotherIdMask);
}


UBYTE     cUiMenuIdValid(MENUFILE *pMenuFile,ULONG Id)
{
  ULONG   SpecialMask;
  ULONG   MotherId;
  UBYTE   Level;
  UBYTE   Result;

  Result = FALSE;
  Level  = pMenuFile->MenuLevel;

  if (Level)
  {
    SpecialMask = pMenuFile->MenuLevels[Level - 1].SpecialFlags;
    MotherId    = pMenuFile->MenuLevels[Level - 1].Id;
    if ((SpecialMask & MENU_SKIP_THIS_MOTHER_ID))
    {
      MotherId &= ~(0x0000000F << ((Level - 1) * 4));
      SpecialMask >>= 28;
      MotherId |=  (SpecialMask << ((Level - 1) * 4));
    }
    if (MotherId == cUiMenuMotherId(Id,Level))
    {
      Id >>= (Level * 4);
      if ((Id & 0x0000000F) && (!(Id & 0xFFFFFFF0)))
      {
        Result = TRUE;
      }
    }
  }
  else
  {
    Id >>= (Level * 4);
    if ((Id & 0x0000000F) && (!(Id & 0xFFFFFFF0)))
    {
      Result = TRUE;
    }
  }

  return (Result);
}


UBYTE     cUiMenuGetNoOfMenus(MENU *pMenu,MENUFILE *pMenuFile)
{
  ULONG   MenuId;
  UBYTE   NoOfMenus;
  UBYTE   Index;

  NoOfMenus = 0;
  for (Index = 0;Index < pMenu->Items;Index++)
  {
    MenuId  = cUiMenuGetId(&pMenu->Data[Index]);

    if (cUiMenuIdValid(pMenuFile,MenuId) == TRUE)
    {
      if ((cUiMenuGetSpecialMask(&pMenu->Data[Index]) & MENU_ONLY_BT_ON))
      {
        // BT module must be on
        if (!(IOMapUi.BluetoothState & BT_STATE_OFF))
        {
          // Yes
          NoOfMenus++;
        }
      }
      else
      {
        if ((cUiMenuGetSpecialMask(&pMenu->Data[Index]) & MENU_ONLY_DATALOG_ENABLED))
        {
          // Datalog menu must be enabled
          if (!(VarsUi.NVData & 0x80))
          {
            // Yes
            NoOfMenus++;
          }
        }
        else
        {
          // No restrictions
          NoOfMenus++;
        }
      }
    }
  }

  return (NoOfMenus);
}


UBYTE     cUiGetMenuItemIndex(MENU *pMenu,MENUFILE *pMenuFile,UBYTE No)
{
  ULONG   MenuId;
  UBYTE   NoOfMenus;
  UBYTE   Index;
  UBYTE   TmpIndex = 0;

  NoOfMenus = 0;
  for (Index = 0;(Index < pMenu->Items) && (No != NoOfMenus);Index++)
  {
    MenuId  = cUiMenuGetId(&pMenu->Data[Index]);

    if (cUiMenuIdValid(pMenuFile,MenuId) == TRUE)
    {
      if ((cUiMenuGetSpecialMask(&pMenu->Data[Index]) & MENU_ONLY_BT_ON))
      {
        // BT module must be on
        if (!(IOMapUi.BluetoothState & BT_STATE_OFF))
        {
          // Yes
          TmpIndex = Index;
          NoOfMenus++;
        }
      }
      else
      {
        if ((cUiMenuGetSpecialMask(&pMenu->Data[Index]) & MENU_ONLY_DATALOG_ENABLED))
        {
          // Datalog menu must be enabled
          if (!(VarsUi.NVData & 0x80))
          {
            // Yes
            TmpIndex = Index;
            NoOfMenus++;
          }
        }
        else
        {
          // No restrictions
          TmpIndex = Index;
          NoOfMenus++;
        }
      }
    }
  }
  if (No != NoOfMenus)
  {
    Index = TmpIndex + 1;
  }

  return (Index);
}



UBYTE     cUiMenuGetNo(MENU *pMenu,ULONG Id,UBYTE Level)
{
  ULONG   MenuId;
  ULONG   MotherId;
  UBYTE   Index;
  UBYTE   No;
  UBYTE   NoOfItems;

  No        = 0;
  NoOfItems = 0;

  MotherId = cUiMenuMotherId(Id,Level);

  for (Index = 0;(Index < pMenu->Items) && (No == 0);Index++)
  {
    MenuId  = cUiMenuGetId(&pMenu->Data[Index]);

    // Scanning all id's until No is found
    if (!(MenuId >> ((Level + 1) * 4)))
    {
      // MenuId is above or on actual level
      if (((MenuId >> (Level * 4)) & 0x0000000F))
      {
        // MenuId is on actual level
        if (MotherId == cUiMenuMotherId(MenuId,Level))
        {
          // Same mother id
          NoOfItems++;
          if (MenuId == Id)
          {
            No = NoOfItems;
          }
        }
      }
    }
  }

  return (No);
}

void      cUiUpdateStatus(void)
{
  UWORD   Tmp;
  UWORD   Hyst;
  UWORD   *pTmp;
  UBYTE   Pointer;

  if (++VarsUi.UpdateCounter >= RUN_STATUS_CHANGE_TIME)
  {
    VarsUi.UpdateCounter = 0;

    // Update running status icon pointer
    if (++VarsUi.Running >= 12)
    {
      VarsUi.Running = 0;
    }

    // Get battery voltage limits
    if ((IoFromAvr.Battery & 0x8000))
    {
      IOMapUi.Rechargeable = 1;
      pTmp = (UWORD*)RechargeableLimits;
      Hyst = RECHARGEABLELIMITHYST;
    }
    else
    {
      IOMapUi.Rechargeable = 0;
      pTmp = (UWORD*)BatteryLimits;
      Hyst = BATTERYLIMITHYST;
    }

    // Calculate battery voltage
    Tmp = IoFromAvr.Battery & 0x03FF;
    Tmp = (UWORD)((float)Tmp * BATTERY_COUNT_TO_MV);

    IOMapUi.BatteryVoltage = Tmp;

    // Find new battery state
    Pointer = 0;
    while ((Tmp > pTmp[Pointer]) && (Pointer < BATTERYLIMITS))
    {
      Pointer++;
    }

    // Change battery state
    if (Pointer != IOMapUi.BatteryState)
    {
      if (Pointer > IOMapUi.BatteryState)
      {
        if (Tmp > (pTmp[IOMapUi.BatteryState] + Hyst))
        {
          IOMapUi.BatteryState   = Pointer;
        }
      }
      else
      {
        IOMapUi.BatteryState   = Pointer;
      }
    }

    // Control toggle and bitmap
    if (IOMapUi.BatteryState)
    {
      VarsUi.BatteryToggle = 0;
      VarsUi.LowBatt = 0;
    }
    else
    {
      if (VarsUi.LowBatt < 255)
      {
        VarsUi.LowBatt++;
      }

      if (VarsUi.BatteryToggle)
      {
        VarsUi.BatteryToggle = 0;
      }
      else
      {
        VarsUi.BatteryToggle = 1;
      }
    }

    // Ensure frequently status updates
    IOMapUi.Flags |= UI_UPDATE;
  }

  if ((IOMapUi.Flags & UI_ENABLE_STATUS_UPDATE))
  {
    if ((IOMapUi.Flags & UI_UPDATE) || (IOMapUi.Flags & UI_REDRAW_STATUS))
    {
      VarsUi.ErrorTimer = 0;
      pMapDisplay->pStatusText   =  (UBYTE*)VarsUi.StatusText;

      // Status line update nessesary
      if (IOMapUi.BatteryState < Status->ItemsX)
      {
        // Update battery status icons
        if (IoFromAvr.Battery & 0x8000)
        {
          VarsUi.NewStatusIcons[STATUSICON_BATTERY] = STATUS_NO_RECHARGEABLE_0 + IOMapUi.BatteryState + VarsUi.BatteryToggle;
        }
        else
        {
          VarsUi.NewStatusIcons[STATUSICON_BATTERY] = STATUS_NO_BATTERY_0 + IOMapUi.BatteryState + VarsUi.BatteryToggle;
        }
      }

      // Update bluetooth status icons
      if ((IOMapUi.BluetoothState & (BT_STATE_VISIBLE | BT_STATE_CONNECTED | BT_STATE_OFF)) < Status->ItemsX)
      {
        VarsUi.NewStatusIcons[STATUSICON_BLUETOOTH] = STATUS_NO_BLUETOOTH_0 + (IOMapUi.BluetoothState & (BT_STATE_VISIBLE | BT_STATE_CONNECTED | BT_STATE_OFF));
      }

      // Update usb status icons
      if (IOMapUi.UsbState < 6)
      {
        VarsUi.NewStatusIcons[STATUSICON_USB] = STATUS_NO_USB_0 + IOMapUi.UsbState;
      }

      // Update running status icons
      if (IOMapUi.RunState == FALSE)
      {
        VarsUi.Running = 0;
      }
      VarsUi.NewStatusIcons[STATUSICON_VM] = STATUS_NO_RUNNING_0 + VarsUi.Running;

      // Update only changed status icons
      for (Pointer = 0;Pointer < STATUSICONS;Pointer++)
      {
        if ((pMapDisplay->StatusIcons[Pointer] != VarsUi.NewStatusIcons[Pointer]))
        {
          pMapDisplay->StatusIcons[Pointer]  = VarsUi.NewStatusIcons[Pointer];
          pMapDisplay->UpdateMask           |= STATUSICON_BIT(Pointer);
        }
      }

      if ((IOMapUi.Flags & UI_REDRAW_STATUS))
      {
        // Entire status line needs to be redrawed
        if (pMapComm->BrickData.Name[0])