bttest.inc

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

//******* TestPrg ************************************************************

#include  "Test1.txt"
#include  "Test2.txt"


extern    void BtIo(void);

const     char  BUILD_DATE[] = __DATE__;
const     char  BUILD_TIME[] = __TIME__;

const     char  MONTH[]  = "JanFebMarAprMajJunJulAugSepOktNovDec";

void      GetProtocolVersion(UBYTE *String)
{
  sprintf((char*)String,"FW         %2X.%02X",(FIRMWAREVERSION >> 8),FIRMWAREVERSION & 0x00FF);
}


void      GetARMBuild(UBYTE *String)
{
  UWORD   Tmp;
  UWORD   Lng;
  char    String1[4];
  char    String2[4];
  
  String1[0] = BUILD_DATE[4];
  String1[1] = BUILD_DATE[5];
  String1[2] = 0;
  
  Tmp = (UWORD)atoi(String1);
  Lng  = 0;
  Lng += sprintf((char*)&String[Lng],"BUILD ");
  Lng += sprintf((char*)&String[Lng],"%02u",Tmp);
  
  String1[0] = BUILD_DATE[0];
  String1[1] = BUILD_DATE[1];
  String1[2] = BUILD_DATE[2];
  String1[3] = 0;
  String2[3] = 0;
  
  Tmp = 0;
  do
  {
    String2[0] = MONTH[0 + 3 * Tmp];
    String2[1] = MONTH[1 + 3 * Tmp];
    String2[2] = MONTH[2 + 3 * Tmp];
    Tmp++;
  }
  while ((Tmp < 12) && (strcmp(String1,String2) != 0));

  Lng += sprintf((char*)&String[Lng],"%02u",Tmp);
  Lng += sprintf((char*)&String[Lng],"%c%c",BUILD_DATE[9],BUILD_DATE[10]);
  Lng += sprintf((char*)&String[Lng],"%c%c",BUILD_TIME[0],BUILD_TIME[1]);
  Lng += sprintf((char*)&String[Lng],"%c%c",BUILD_TIME[3],BUILD_TIME[4]);
}


void      GetBC4Build(UBYTE *String)
{
  sprintf((char*)String,"BC4        %2X.%02X",pMapComm->BrickData.BluecoreVersion[1],pMapComm->BrickData.BluecoreVersion[0]);
}


void      GetAVRBuild(UBYTE *String)
{
  sprintf((char*)String,"AVR         %1u.%02u",((IoFromAvr.Battery >> 13) & 3),((IoFromAvr.Battery >> 10) & 7));
}

  
void      GetBC4Address(UBYTE *String)
{
  UWORD   Count;
  UBYTE   Tmp;
  
  Count = (UWORD)sprintf((char*)String,"ID  ");
  for (Tmp = 0;(Tmp < (SIZE_OF_BDADDR - 1)) && (Count <= (DISPLAYLINE_LENGTH - 2));Tmp++)
  {
    Count += (UWORD)sprintf((char*)&String[Count],"%02X",(UWORD)(pMapComm->BrickData.BdAddr[Tmp]) & 0xFF);
  }
}


enum      TSTPRG
{
  SYSTEM_INIT = 1,
    SYSTEM_UNLOCK_INIT,
    SYSTEM_UNLOCK,
  SYSTEM_PAGE,
    TIMER_INIT,
      TIMER_SHOW,
      TIMER_HOLD,
    BT_PAGE,
      BT_RESET,
        BT_RESETTING,
      BT_LIST_INIT,
        BT_LIST,
        BT_CONN_INIT,
          BT_CONN,
      BT_UPDATE_FW,
  TSTPRG_INIT,
    TSTPRG_SELECT_SUBTEST,

    TSTPRG_SENSOR_INIT,
      TSTPRG_SELECT_SENSOR,
      TSTPRG_TOUCH_SENSOR_INIT,
        TSTPRG_TOUCH_SENSOR,
      TSTPRG_SOUND_SENSOR_SELECT,
        TSTPRG_SOUND_SENSOR_INIT,
          TSTPRG_SOUND_SENSOR,
      TSTPRG_LIGHT_SENSOR_SELECT,
        TSTPRG_LIGHT_SENSOR_INIT,
          TSTPRG_LIGHT_SENSOR,
    TSTPRG_SKIP_SENSOR,

    TSTPRG_RCX_INIT,
      TSTPRG_RCX_SELECT,
      TSTPRG_RCX_DISPLAY_INIT,
        TSTPRG_RCX_DISPLAY,
      TSTPRG_RCX_INPUT_SELECT,
        TSTPRG_RCX_INPUT_INIT,
          TSTPRG_RCX_INPUT,
        TSTPRG_RCX_DIGITAL_INIT,
          TSTPRG_RCX_DIGITAL_OK,
          TSTPRG_RCX_DIGITAL_FAIL,
          TSTPRG_RCX_DIGITAL,
      TSTPRG_RCX_MOTOR_INIT,
        TSTPRG_RCX_MOTOR,
      TSTPRG_SKIP_RCX_MOTOR,
    TSTPRG_SKIP_RCX,

    TSTPRG_MOTOR_INIT,
      TSTPRG_MOTOR,
    TSTPRG_SKIP_MOTOR,

  TSTPRG_SKIP,
  TSTPRG_WAIT
};

const     UBYTE TXT_EMPTY[]                 = "                ";
const     UBYTE TXT_LINE[]                  = "----------------";

#ifdef  TESTPRG

const     UBYTE TXT_TEST[]                  = "Timer Test   Bt ";

const     UBYTE TXT_TIMER[]                 = "Reset Hold      ";
const     UBYTE TXT_TIMER_HOLD[]            = "    Continue    ";         

const     UBYTE TXT_LAST[]                  = "Last UI->BT Cmd.";
const     UBYTE TXT_BT_PAGE[]               = "Reset List  BtIo"; 

const     UBYTE TXT_RESETTING[]             = "   Resetting!   ";

const     UBYTE TXT_BT_LIST[]               = "Down ConTab  Up "; 
const     UBYTE TXT_BT_CONN[]               = "Down Update  Up "; 

const     UBYTE TXT_BTUPDATE[]              = "BT update mode !";
const     UBYTE TXT_DONE[]                  = "   When done    ";
const     UBYTE TXT_RESET[]                 = " activate reset ";
const     UBYTE TXT_REBOOT[]                = "button to reboot";

const     UBYTE TXT_TESTPRG[]               = " TestPrg  V0.08 ";
const     UBYTE TXT_SELECT[]                = "Select sub test ";
const     UBYTE TXT_SUBTEST[]               = "Sens. RCX  Motor";

const     UBYTE TXT_SELECT_SENSOR[]         = " Select sensor  ";
const     UBYTE TXT_SENSORS[]               = "Touch Snd. Light";

const     UBYTE TXT_SELECT_TYPE[]           = "  Select type   ";
const     UBYTE TXT_SOUND_SENSORS[]         = " DB         DBA ";
const     UBYTE TXT_LIGHT_SENSORS[]         = "Pasive    Active";

const     UBYTE TXT_SENSOR_TOUCH[]          = "Touch Sensor Tst";
const     UBYTE TXT_SENSOR_SOUND_DB[]       = "DB   Sound Sens.";
const     UBYTE TXT_SENSOR_SOUND_DBA[]      = "DBA  Sound Sens.";
const     UBYTE TXT_SOUND_STOP[]            = "440Hz Stop  4KHz";
const     UBYTE TXT_SENSOR_LIGHT_PASIVE[]   = "Pas. Light Sens.";
const     UBYTE TXT_SENSOR_LIGHT_ACTIVE[]   = "Act. Light Sens.";

const     UBYTE TXT_SUBTEST_STOP[]          = "      Stop      ";

const     UBYTE TXT_MOTOR[]                 = "   Motor test   ";
const     UBYTE TXT_MOTOR_HEADER[]          = "Outp  Set    Cnt";
const     UBYTE TXT_MOTOR_STOP[]            = "Bwd   Stop   Fwd";

const     UBYTE TXT_RCX[]                   = "    RCX test    ";
const     UBYTE TXT_RCX_STOP[]              = "Inp   Disp  Outp";
const     UBYTE TXT_RCX_INPUT_PASIVE[]      = "Input pasive Tst";
const     UBYTE TXT_RCX_INPUT_ACTIVE[]      = "Input active Tst";
const     UBYTE TXT_RCX_INPUT_SELECT[]      = "Pas.  Act.  Dig.";
const     UBYTE TXT_RCX_INPUT_DIGITAL[]     = "Digital I/O  Tst";
const     UBYTE TXT_RCX_DIGITAL_OK[]        = "       OK       ";
const     UBYTE TXT_RCX_DIGITAL_FAIL[]      = "      FAIL      ";
const     UBYTE TXT_MOTOR_NEXT[]            = "Bwd   Next   Fwd";


void      TestPrgRunMotor(UBYTE No,SBYTE Speed)
{
  pMapOutPut->Outputs[No].Mode       = MOTORON | BRAKE;
  pMapOutPut->Outputs[No].Speed      = Speed;
  pMapOutPut->Outputs[No].TachoLimit = 0;
  pMapOutPut->Outputs[No].RunState   = MOTOR_RUN_STATE_RUNNING;
  pMapOutPut->Outputs[No].Flags      = UPDATE_MODE | UPDATE_SPEED | UPDATE_TACHO_LIMIT;
}

void      TestPrgFloatMotor(UBYTE No)
{
  pMapOutPut->Outputs[No].Mode       = 0;
  pMapOutPut->Outputs[No].Speed      = 0;
  pMapOutPut->Outputs[No].TachoLimit = 0;
  pMapOutPut->Outputs[No].RunState   = MOTOR_RUN_STATE_RUNNING;
  pMapOutPut->Outputs[No].Flags      = UPDATE_MODE | UPDATE_SPEED | UPDATE_TACHO_LIMIT;
}

SBYTE     TestPrgReadMotor(UBYTE No)
{
  return ((SBYTE)(pMapOutPut->Outputs[No].TachoCnt / 360));
}

#endif


UBYTE     TestPrg(UBYTE Dummy)
{
  static  UWORD Count;
  static  UBYTE TxtBuffer[TEXTLINES][DISPLAYLINE_LENGTH + 1];
  static  UBYTE State = SYSTEM_INIT;
#ifdef TESTPRG  
  static  UWORD Pointer;
  static  UWORD InputValues[NO_OF_INPUTS];
  static  SWORD OutputValues[NO_OF_OUTPUTS];
  static  UBYTE VolumeSave;
  static  UBYTE Timer;
  static  UBYTE SubState = 0;
  UBYTE   Tmp;
#endif

  Dummy = Dummy;
  switch (State)
  {
    case SYSTEM_INIT :
    {
      GetProtocolVersion(TxtBuffer[0]);
      GetAVRBuild(TxtBuffer[1]);
      GetBC4Build(TxtBuffer[2]);
      GetARMBuild(TxtBuffer[3]);
      GetBC4Address(TxtBuffer[4]);
      
      pMapDisplay->pTextLines[TEXTLINE_3] = (UBYTE*)TxtBuffer[0];
      pMapDisplay->pTextLines[TEXTLINE_4] = (UBYTE*)TxtBuffer[1];
      pMapDisplay->pTextLines[TEXTLINE_5] = (UBYTE*)TxtBuffer[2];
      pMapDisplay->pTextLines[TEXTLINE_6] = (UBYTE*)TxtBuffer[3];
      pMapDisplay->pTextLines[TEXTLINE_7] = (UBYTE*)TxtBuffer[4];
      pMapDisplay->pTextLines[TEXTLINE_8] = (UBYTE*)TXT_EMPTY;
      pMapDisplay->UpdateMask            |= (TEXTLINE_BIT(TEXTLINE_3) | TEXTLINE_BIT(TEXTLINE_4) | TEXTLINE_BIT(TEXTLINE_5) | TEXTLINE_BIT(TEXTLINE_6) | TEXTLINE_BIT(TEXTLINE_7) | TEXTLINE_BIT(TEXTLINE_8));

#ifdef TESTPRG
      SubState  = 0;
#endif      
      State     = SYSTEM_UNLOCK_INIT;
    }
    break;

#ifndef TESTPRG

    case SYSTEM_UNLOCK_INIT : // ENTER * 1 + LEFT * 3 + RIGHT * 2 + ENTER * 1 = TEST MENU
    {
      if (cUiReadButtons() != BUTTON_NONE)
      {
        State = TSTPRG_SKIP;
      }
    }
    break;

#else

    case SYSTEM_UNLOCK_INIT : // ENTER * 1 + LEFT * 3 + RIGHT * 2 + ENTER * 1 = TEST MENU
    {
      Tmp = cUiReadButtons();
      switch (Tmp)
      {
        case BUTTON_ENTER :
        {
          switch (SubState)
          {
            case 0 :
            {
              SubState = 1;
              Pointer  = 0;
              Count    = 0;
            }
            break;
            
            case 3 :
            {
              State = SYSTEM_UNLOCK;
            }
            break;
            
            default :
            {
              Tmp = BUTTON_EXIT;
            }
            break;
            
          }
        }
        break;

        case BUTTON_NONE :
        {
        }
        break;

        default :
        {
          switch (SubState)
          {
            case 0 :
            {
              Tmp = BUTTON_EXIT;
            }
            break;
  
            case 1 :
            {
              if (Tmp == BUTTON_LEFT)
              {
                if (++Count >= 3)
                {
                  Count    = 0;
                  SubState = 2;
                }
                Pointer = 0;
              }
              else
              {
                Tmp = BUTTON_EXIT;
              }
            }
            break;
            
            case 2 :
            {
              if (Tmp == BUTTON_RIGHT)
              {
                if (++Count >= 2)
                {
                  SubState = 3;
                }
                Pointer = 0;
              }
              else
              {
                Tmp = BUTTON_EXIT;
              }
            }
            break;
            
          }
        }
        break;
        
      }
      Pointer++;
      if (((SubState) && (Pointer > 500)) || (Tmp == BUTTON_EXIT))
      {
        State = TSTPRG_SKIP;
      }
    }
    break;
  
    case SYSTEM_UNLOCK :
    {
      pMapDisplay->pTextLines[TEXTLINE_8] = (UBYTE*)TXT_TEST;
      pMapDisplay->UpdateMask            |= TEXTLINE_BIT(TEXTLINE_8);
      State = SYSTEM_PAGE;
    }
    break;
  
    case SYSTEM_PAGE :
    {
      switch (cUiReadButtons())
      {
        case BUTTON_ENTER :
        {
          IOMapUi.Flags                      &= ~UI_ENABLE_STATUS_UPDATE;
          pMapDisplay->EraseMask             |=  SCREEN_BIT(SCREEN_BACKGROUND);
          State = TSTPRG_INIT;
        }
        break;

        case BUTTON_EXIT :
        {
          Count = 0;
          State = TSTPRG_SKIP;
        }
        break;

        case BUTTON_LEFT :
        {
          IOMapUi.Flags                      &= ~UI_ENABLE_STATUS_UPDATE;
          pMapDisplay->EraseMask             |=  SCREEN_BIT(SCREEN_BACKGROUND);
          pMapDisplay->pTextLines[TEXTLINE_1] = (UBYTE*)TXT_EMPTY;
          pMapDisplay->pTextLines[TEXTLINE_2] = (UBYTE*)TXT_EMPTY;
          pMapDisplay->pTextLines[TEXTLINE_3] = (UBYTE*)TXT_EMPTY;
          pMapDisplay->pTextLines[TEXTLINE_4] = (UBYTE*)TXT_EMPTY;
          pMapDisplay->pTextLines[TEXTLINE_5] = (UBYTE*)TXT_EMPTY;
          pMapDisplay->pTextLines[TEXTLINE_6] = (UBYTE*)TXT_EMPTY;
          pMapDisplay->pTextLines[TEXTLINE_7] = (UBYTE*)TXT_EMPTY;