c_comm.c

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

void      cCommCpyToUpper(UBYTE *pDst, UBYTE *pSrc, UBYTE Length)
{
  UBYTE   Tmp;

  for(Tmp = 0; Tmp < Length; Tmp++)
  {
    pDst[Tmp] =(UBYTE)toupper((UWORD)pSrc[Tmp]);
  }

  /* The requried length has been copied - now fill with zeros */
  for(Tmp = Length; Tmp < (FILENAME_LENGTH + 1); Tmp++)
  {
    pDst[Tmp] = '\0';
  }
}

void     cCommCopyFileName(UBYTE *pDst, UBYTE *pSrc)
{
  UBYTE  Tmp;

  for(Tmp = 0; Tmp < (FILENAME_LENGTH + 1); Tmp++, pDst++)
  {
    if ('\0' != *pSrc)
    {
      *pDst = *pSrc;
      pSrc++;
    }
    else
    {
      *pDst = '\0';
    }
  }
}

void cCommSendHiSpeedData(void)
{
  VarsComm.HsModuleOutBuf.OutPtr = 0;
  for (VarsComm.HsModuleOutBuf.InPtr = 0; VarsComm.HsModuleOutBuf.InPtr < IOMapComm.HsOutBuf.InPtr; VarsComm.HsModuleOutBuf.InPtr++)
  {
    VarsComm.HsModuleOutBuf.Buf[VarsComm.HsModuleOutBuf.InPtr] = IOMapComm.HsOutBuf.Buf[IOMapComm.HsOutBuf.OutPtr];
    IOMapComm.HsOutBuf.OutPtr++;
  }
  dHiSpeedSendData(VarsComm.HsModuleOutBuf.Buf, (VarsComm.HsModuleOutBuf.InPtr - VarsComm.HsModuleOutBuf.OutPtr));
}

void cCommReceivedHiSpeedData(void)
{
  UWORD NumberOfBytes;
  UWORD Tmp;

  dHiSpeedReceivedData(&NumberOfBytes);

  if (NumberOfBytes != 0)
  {
    for (Tmp = 0; Tmp < NumberOfBytes; Tmp++)
    {
      IOMapComm.HsInBuf.Buf[IOMapComm.HsInBuf.InPtr] = VarsComm.HsModuleInBuf.Buf[Tmp];
      IOMapComm.HsInBuf.InPtr++;
      if (IOMapComm.HsInBuf.InPtr > (SIZE_OF_HSBUF - 1))
      {
        IOMapComm.HsInBuf.InPtr = 0;
      }
      VarsComm.HsModuleInBuf.Buf[Tmp] = 0;
    }

    /* Now new data is available from the HIGH SPEED port ! */
  }
}

UBYTE cCommBtValidateCmd(void)
{
  UWORD CheckSumTmp = 0;
  UBYTE Tmp, CheckSumHigh, CheckSumLow;

  for (Tmp = 0; Tmp < (IOMapComm.BtInBuf.Buf[0] - 1);Tmp++)
  {
    CheckSumTmp += IOMapComm.BtInBuf.Buf[Tmp];
  }
  CheckSumTmp = (UWORD) (1 + (0xFFFF - CheckSumTmp));
  CheckSumHigh = (UBYTE)((CheckSumTmp & 0xFF00)>>8);
  CheckSumLow = (UBYTE)(CheckSumTmp & 0x00FF);

  if ((CheckSumHigh == IOMapComm.BtInBuf.Buf[IOMapComm.BtInBuf.Buf[0] - 1]) && (CheckSumLow == IOMapComm.BtInBuf.Buf[IOMapComm.BtInBuf.Buf[0]]))
  {
    return(TRUE);
  }
  else
  {
    return(FALSE);
  }
}

void      cCommClearStreamStatus(void)
{
  IOMapComm.BtConnectTable[0].StreamStatus = 0;
  IOMapComm.BtConnectTable[1].StreamStatus = 0;
  IOMapComm.BtConnectTable[2].StreamStatus = 0;
  IOMapComm.BtConnectTable[3].StreamStatus = 0;
}

void      cCommUpdateBt(void)
{
  UBYTE   Tmp, Tmp2, Handle;

  Tmp  = 0;
  Tmp2 = 0;

  switch(VarsComm.ActiveUpdate)
  {
    case UPD_RESET:
    {

      switch(VarsComm.UpdateState)
      {
        case 0:
        {
          /* Setup Reset sequence */
          pMapUi->BluetoothState  = BT_STATE_OFF;
          VarsComm.UpdateState    = 1;
        }
        break;

        case 1:
        {
          cCommsBtReset(&(VarsComm.UpdateState));
        }
        break;

        case 2:
        {
          (VarsComm.UpdateState)++;
          dBtSendBtCmd((UBYTE)MSG_GET_LOCAL_ADDR, 0, 0, NULL, NULL, NULL, NULL);
        }
        break;

        case 3:
        {
          if (MSG_GET_LOCAL_ADDR_RESULT == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            cCommCopyBdaddr((IOMapComm.BrickData.BdAddr), &(IOMapComm.BtInBuf.Buf[BT_CMD_BYTE + 1]));
            dUsbStoreBtAddress( &(IOMapComm.BtInBuf.Buf[BT_CMD_BYTE + 1]));
            dBtSendBtCmd((UBYTE)MSG_GET_FRIENDLY_NAME, 0, 0, NULL, NULL, NULL, NULL);
            VarsComm.BtAdrStatus = INITIALIZED;
            (VarsComm.UpdateState)++;
          }
        }
        break;

        case 4:
        {
          if (MSG_GET_FRIENDLY_NAME_RESULT == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            memcpy(IOMapComm.BrickData.Name, &(IOMapComm.BtInBuf.Buf[BT_CMD_BYTE + 1]), SIZE_OF_BRICK_NAME);
            pMapUi->Flags |= UI_REDRAW_STATUS;
            IOMapComm.BtDeviceCnt     = 0;
            IOMapComm.BtDeviceNameCnt = 0;
            dBtSendBtCmd((UBYTE)MSG_DUMP_LIST, 0, 0, NULL, NULL, NULL, NULL);
            (VarsComm.UpdateState)++;
          }
        }
        break;

        case 5:
        {
          if (MSG_LIST_ITEM == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            cCommCopyBdaddr((IOMapComm.BtDeviceTable[IOMapComm.BtDeviceCnt].BdAddr), &(IOMapComm.BtInBuf.Buf[2]));
            cCommInsertBtName(IOMapComm.BtDeviceTable[IOMapComm.BtDeviceCnt].Name, &(IOMapComm.BtInBuf.Buf[9]));
            IOMapComm.BtDeviceTable[IOMapComm.BtDeviceCnt].DeviceStatus = BT_DEVICE_KNOWN;

            memcpy(IOMapComm.BtDeviceTable[IOMapComm.BtDeviceCnt].ClassOfDevice, &(IOMapComm.BtInBuf.Buf[9+SIZE_OF_BT_NAME]), sizeof(IOMapComm.BtDeviceTable[IOMapComm.BtDeviceCnt].ClassOfDevice));

            IOMapComm.BtDeviceCnt++;
            IOMapComm.BtDeviceNameCnt++;
          }

          if (MSG_LIST_DUMP_STOPPED == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            dBtSendBtCmd((UBYTE)MSG_GET_VERSION, 0, 0, NULL, NULL, NULL, NULL);
            (VarsComm.UpdateState)++;
          }
          IOMapComm.BtInBuf.Buf[BT_CMD_BYTE] = 0;
        }
        break;

        case 6:
        {
          if (MSG_GET_VERSION_RESULT == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {

            IOMapComm.BrickData.BluecoreVersion[0] = IOMapComm.BtInBuf.Buf[3];
            IOMapComm.BrickData.BluecoreVersion[1] = IOMapComm.BtInBuf.Buf[2];

            /* BtHwStatus indicates cold boot or user interaction */
            if (BT_DISABLE == IOMapComm.BrickData.BtHwStatus)
            {

              /* This is from brick turning on */
              dBtSendBtCmd((UBYTE)MSG_GET_BRICK_STATUSBYTE, 0, 0, NULL, NULL, NULL, NULL);
            }
            else
            {

              /* this is user interaction setting the brick on */
              dBtSendBtCmd((UBYTE)MSG_SET_BRICK_STATUSBYTE, BT_ENABLE, 0, NULL, NULL, NULL, NULL);
            }
            (VarsComm.UpdateState)++;
            pMapUi->Flags |= UI_REDRAW_STATUS;
          }
        }
        break;

        case 7:
        {
          if (MSG_GET_BRICK_STATUSBYTE_RESULT == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            IOMapComm.BrickData.TimeOutValue = IOMapComm.BtInBuf.Buf[BT_CMD_BYTE + 2];

            /* Check for brick to be on or off */
            if (BT_ENABLE == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE + 1])
            {
              pMapUi->BluetoothState        &= ~BT_STATE_OFF;
              IOMapComm.BrickData.BtHwStatus = BT_ENABLE;
              dBtSendBtCmd((UBYTE)MSG_GET_DISCOVERABLE, 0, 0, NULL, NULL, NULL, NULL);
              (VarsComm.UpdateState)++;
            }
            else
            {
              SETBtOff;
              IOMapComm.BrickData.BtHwStatus = BT_ENABLE;
              SETBtStateIdle;
              *(VarsComm.pRetVal) = SUCCESS;
            }
          }
          if (MSG_SET_BRICK_STATUSBYTE_RESULT == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {

            /* brick to be on*/
            pMapUi->BluetoothState        &= ~BT_STATE_OFF;
            IOMapComm.BrickData.BtHwStatus = BT_ENABLE;
            dBtSendBtCmd((UBYTE)MSG_GET_DISCOVERABLE, 0, 0, NULL, NULL, NULL, NULL);
            (VarsComm.UpdateState)++;
          }
        }
        break;

        case 8:
        {
          if (MSG_GET_DISCOVERABLE_RESULT == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            if (IOMapComm.BtInBuf.Buf[2] & 0x01)
            {
              IOMapComm.BrickData.BtStateStatus |= BT_BRICK_VISIBILITY;
              pMapUi->BluetoothState            |= BT_STATE_VISIBLE;
            }
            else
            {
              IOMapComm.BrickData.BtStateStatus &= ~BT_BRICK_VISIBILITY;
              pMapUi->BluetoothState            &= ~BT_STATE_VISIBLE;
            }
            dBtSendBtCmd((UBYTE)MSG_OPEN_PORT, 0, 0, NULL, NULL, NULL, NULL);
            (VarsComm.UpdateState)++;
          }
        }
        break;

        case 9:
        {

          if (MSG_PORT_OPEN_RESULT == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            if (IOMapComm.BtInBuf.Buf[BT_CMD_BYTE + 1] & 0x01)
            {
              IOMapComm.BrickData.BtStateStatus |= BT_BRICK_PORT_OPEN;
            }
            else
            {
              IOMapComm.BrickData.BtStateStatus &= ~BT_BRICK_PORT_OPEN;
            }

            SETBtStateIdle;
            *(VarsComm.pRetVal) = SUCCESS;
          }
        }
        break;
      }
    }
    break;

    case UPD_FACTORYRESET:
    {
      switch(VarsComm.UpdateState)
      {

        case 0:
        {
          if (BT_STATE_OFF & (pMapUi->BluetoothState))
          {

            /* Bluetooth is off - now start it up  */
            (VarsComm.UpdateState)++;
          }
          else
          {

            /* BT is already on - continue */
            (VarsComm.UpdateState) += 2;
          }
        }
        break;
        case 1:
        {
          cCommsBtReset(&(VarsComm.UpdateState));
        }
        break;
        case 2:
        {
          cCommsSetCmdMode(&(VarsComm.UpdateState));
        }
        break;
        case 3:
        {
          cCommsDisconnectAll(&(VarsComm.UpdateState));
        }
        break;
        case 4:
        {

          /* Now bc4 is in cmd mode now factory can be sent */
          /* Just leave the BC4 in cmd mode                 */
          dBtSendBtCmd((UBYTE)MSG_SET_FACTORY_SETTINGS, 0, 0, NULL, NULL, NULL, NULL);
          (VarsComm.UpdateState)++;
        }
        break;
        case 5:
        {
          if (MSG_SET_FACTORY_SETTINGS_ACK == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {
            SETBtStateIdle;
            IOMapComm.BrickData.BtHwStatus = BT_DISABLE; /* Boot BT like cold boot*/
            VarsComm.ActiveUpdate          = UPD_RESET;
          }
        }
        break;
      }
    }
    break;

    case UPD_BRICKNAME:
    {
      switch(VarsComm.UpdateState)
      {
        case 0:
        {

          if (BT_STATE_OFF & (pMapUi->BluetoothState))
          {

            /* Bluetooth is off - now start it up  */
            (VarsComm.UpdateState)++;
          }
          else
          {
            VarsComm.UpdateState = 2;
          }
        }
        break;

        case 1:
        {
          cCommsBtReset(&(VarsComm.UpdateState));
        }
        break;

        case 2:
        {
          VarsComm.BtUpdateDataConnectNr = 0;
          if (BT_ARM_DATA_MODE == VarsComm.BtState)
          {
            for (Tmp = 0; Tmp < SIZE_OF_BT_CONNECT_TABLE; Tmp++)
            {
              if (IOMapComm.BtConnectTable[Tmp].StreamStatus)
              {
                VarsComm.BtUpdateDataConnectNr = Tmp | 0x80;
              }
            }
            (VarsComm.UpdateState)++;
          }
          else
          {
            (VarsComm.UpdateState) += 2;
          }
        }
        break;

        case 3:
        {
          cCommsSetCmdMode(&(VarsComm.UpdateState));
        }
        break;

        case 4:
        {

          /* Brick name has been updated prior to this */
          dBtSendBtCmd((UBYTE)MSG_SET_FRIENDLY_NAME, 0, 0, NULL, IOMapComm.BrickData.Name, NULL, NULL);
          (VarsComm.UpdateState)++;
        }
        break;

        case 5:
        {
          if (MSG_SET_FRIENDLY_NAME_ACK == IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
          {

            /* Set name has been executed */
            if (VarsComm.BtUpdateDataConnectNr & 0x80)
            {
              dBtSendBtCmd((UBYTE)MSG_OPEN_STREAM, IOMapComm.BtConnectTable[(VarsComm.BtUpdateDataConnectNr & ~0x80)].HandleNr,
                              0, NULL, NULL, NULL, NULL);
              (VarsComm.UpdateState)++;
            }
            else
            {
              if (BT_STATE_OFF & (pMapUi->BluetoothState))
              {
                SETBtOff;
              }
              SETBtStateIdle;
              *(VarsComm.pRetVal) = SUCCESS;
            }
            pMapUi->Flags |= UI_REDRAW_STATUS;
          }
        }
        break;
        case 6:
        {
          if (VarsComm.BtBcPinLevel)
          {
            IOMapComm.BtConnectTable[(VarsComm.BtUpdateDataConnectNr & ~0x80)].StreamStatus = 1;
            *(VarsComm.pRetVal) = SUCCESS;
            SETBtDataState;
            SETBtStateIdle;
          }
        }
        break;
      }
    }
    break;

    case UPD_REQCMDMODE:
    {
      switch(VarsComm.UpdateState)