c_comm.c

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

      Status = pMapLoader->pFunc(IOMAPWRITE, (UBYTE *)&ModuleId, &pInBuf[7], &FileLength);

      pOutBuf[0]  = LOADER_ERR_BYTE(Status);
      pOutBuf[5]  = (UBYTE)FileLength;
      pOutBuf[6]  = (UBYTE)(FileLength >> 8);

      *pLength = 7;
    }
    break;

    case BOOTCMD:
    {

      UBYTE Tmp;

      /* The boot command is only allowed by USB - as firmware download can ONLY */
      /* be send by USB                                                          */
      pOutBuf[0] =  LOADER_ERR_BYTE(UNDEFINEDERROR);
      memset(&(pOutBuf[1]), 0, 4);
      *pLength = 5;

      if (CmdBit & USB_CMD_READY)
      {

        Tmp = 0;
        while((Tmp < (sizeof(BootString) - 1)) && (BootString[Tmp] == pInBuf[Tmp+1]))
        {
          Tmp++;
        }
        if (Tmp == (sizeof(BootString) - 1))
        {

          /* Yes valid boot sequence */
          pMapDisplay->Flags  &= ~DISPLAY_ON;
          pMapDisplay->Flags  |=  DISPLAY_REFRESH;
          pMapIoCtrl->PowerOn  = BOOT;
          pOutBuf[0] =  LOADER_ERR_BYTE(SUCCESS);
          pOutBuf[1] = 'Y';
          pOutBuf[2] = 'e';
          pOutBuf[3] = 's';
          pOutBuf[4] = '\0';
        }
      }
    }
    break;

    case SETBRICKNAME:
    {

      UWORD RtnVal;

      *pLength = 1;

      /* Update the name in the BT device - reply for this command is send */
      /* before command is actually executed                               */
      if (SUCCESS == cCommReq(SETBTNAME, 0, 0, 0, &pInBuf[1], &RtnVal))
      {
        pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);
        cCommInsertBtName(IOMapComm.BrickData.Name, &pInBuf[1]);
        pMapUi->Flags |= UI_REDRAW_STATUS;
      }
      else
      {
        pOutBuf[0] = LOADER_ERR_BYTE(BTBUSY);
      }
    }
    break;

    case BTGETADR:
    {
      UBYTE Tmp;
      UBYTE *pAdr;

      pAdr = (IOMapComm.BrickData.BdAddr);
      for (Tmp = 0; Tmp < 7; Tmp++)
      {
        pOutBuf[Tmp + 1] = pAdr[Tmp];
      }
      pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);
      *pLength = 8;
    }
    break;

    case DEVICEINFO:
    {

      pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);

      /* Brick name */
      memcpy(&(pOutBuf[1]), IOMapComm.BrickData.Name, 15);

      /* BT address */
      cCommCopyBdaddr(&(pOutBuf[16]), (IOMapComm.BrickData.BdAddr));

      /* Link quality of the 4 possible connected devices */
      pOutBuf[23] = IOMapComm.BtConnectTable[0].LinkQuality;
      pOutBuf[24] = IOMapComm.BtConnectTable[1].LinkQuality;
      pOutBuf[25] = IOMapComm.BtConnectTable[2].LinkQuality;
      pOutBuf[26] = IOMapComm.BtConnectTable[3].LinkQuality;

      /* Free user flash */
      memcpy(&(pOutBuf[27]), &(pMapLoader->FreeUserFlash), sizeof(pMapLoader->FreeUserFlash));

      /* Set answer length */
      *pLength = 31;
    }
    break;

    case DELETEUSERFLASH:
    {
      Status     = pMapLoader->pFunc(DELETEUSERFLASH, NULL, NULL, NULL);
      pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);
      *pLength   = 1;
    }
    break;

    case POLLCMDLEN:
    {

      pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);
      pOutBuf[1] = pInBuf[1];                 /* This is the Buf Number */
      if (0 == pInBuf[1])
      {

        /* USB poll buffer */
        pOutBuf[2] = ((IOMapComm.UsbPollBuf.InPtr - IOMapComm.UsbPollBuf.OutPtr) & (SIZE_OF_USBBUF - 1));
      }
      else
      {

        /* HI speed poll buffer */
        pOutBuf[2] = ((IOMapComm.HsInBuf.InPtr - IOMapComm.HsInBuf.OutPtr) & (SIZE_OF_HSBUF - 1));
      }
      *pLength = 3;
    }
    break;

    case POLLCMD:
    {
      UBYTE Tmp;
      UBYTE MaxBufData;

      pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);
      pOutBuf[1] = pInBuf[1];
      *pLength   = pInBuf[2];

      if (CmdBit & USB_CMD_READY)
      {
        MaxBufData = (SIZE_OF_USBDATA - 5); /* Substract wrapping */
      }
      else
      {
        MaxBufData = (SIZE_OF_BTBUF - 7);  /* Substract wrapping + length bytes for BT*/
      }

      if (0x00 == pInBuf[1])
      {

        /* Data from USB poll buffer are requested */
        if (*pLength <= MaxBufData)
        {
          for (Tmp = 0; ((Tmp < (*pLength)) && (IOMapComm.UsbPollBuf.InPtr != IOMapComm.UsbPollBuf.OutPtr)); Tmp++)
          {
            pOutBuf[3 + Tmp]            = IOMapComm.UsbPollBuf.Buf[IOMapComm.UsbPollBuf.OutPtr];
            IOMapComm.UsbPollBuf.OutPtr = ((IOMapComm.UsbPollBuf.OutPtr) + 1) % SIZE_OF_USBBUF;
          }
          pOutBuf[2] = Tmp;

          /* if end of buffer has been reached fill up with zeros */
          memset(&(pOutBuf[Tmp + 3]), 0x00, (*pLength - Tmp));
        }
        else
        {

          /* if more data requested than possible to return */
          pOutBuf[0] = LOADER_ERR_BYTE(UNDEFINEDERROR);
          pOutBuf[1] = pInBuf[1];                           /* This is buffer number */
          pOutBuf[2] = 0;                                   /* no of bytes returned  */
          *pLength   = 0;
        }
      }
      else
      {

        /* Data from hi speed buffer are requested */
        if (*pLength <= MaxBufData)
        {
          for (Tmp = 0; ((Tmp < (*pLength)) && (IOMapComm.HsInBuf.InPtr != IOMapComm.HsInBuf.OutPtr)); Tmp++)
          {
            pOutBuf[3 + Tmp]         = IOMapComm.HsInBuf.Buf[IOMapComm.HsInBuf.OutPtr];
            IOMapComm.HsInBuf.OutPtr = ((IOMapComm.HsInBuf.OutPtr) + 1) % SIZE_OF_USBBUF;
          }
          pOutBuf[2] = Tmp;

          /* if end of buffer has been reached fill up with zeros */
          memset(&(pOutBuf[Tmp + 3]), 0x00, (*pLength - Tmp));
        }
        else
        {

          /* if more data requested than possible to return */
          pOutBuf[0] = LOADER_ERR_BYTE(UNDEFINEDERROR);
          pOutBuf[1] = pInBuf[1];                           /* This is buffer number */
          pOutBuf[2] = 0;                                   /* no of bytes returned  */
          *pLength   = 0;
        }
      }
      (*pLength) += 3; /* Add 3 bytes for the status byte, length byte and Buf no */
    }
    break;

    case BTFACTORYRESET:
    {
      UWORD RtnVal;

      if (CmdBit & USB_CMD_READY)
      {
        if (SUCCESS == cCommReq(FACTORYRESET, 0, 0, 0, NULL, &RtnVal))
        {

          /* Request success */
          pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);
        }
        else
        {

          /* BT request error */
          pOutBuf[0] = LOADER_ERR_BYTE(UNDEFINEDERROR);
        }
      }
      else
      {

        /* Factory reset request cannot be done by bluetooth */
        pOutBuf[0] = LOADER_ERR_BYTE(UNDEFINEDERROR);
      }
      *pLength = 1;
    }
    break;

    default:
    {
    }
    break;
  }
  return(Status);
}


UWORD     cCommReceivedBtData(void)
{
  UWORD   NumberOfBytes;
  UWORD   BytesToGo;
  UWORD   RtnVal;

  RtnVal = dBtReceivedData(&NumberOfBytes, &BytesToGo);
  if (TRUE == RtnVal)
  {

    /* Everything is fine go on */
    if (NumberOfBytes != 0)
    {

      /* Copy the bytes into the IOMapBuffer */
      memcpy((IOMapComm.BtInBuf.Buf), (VarsComm.BtModuleInBuf.Buf), NumberOfBytes);

      if (VarsComm.BtState == BT_ARM_CMD_MODE)
      {

        /* Call the BC4 command interpreter */
        cCommBtCmdInterpreter();
        IOMapComm.BtInBuf.InPtr  = 0;
      }
      else
      {
        
        /* ActiveUpdate has to be idle because BC4 can send stream data even if CMD */
        /* mode has been requested - dont try to interprete the data                */
        /* VarsComm.CmdSwitchCnt != 0 if a transition to Cmd mode is in process     */
        if ((VarsComm.BtState == BT_ARM_DATA_MODE) && (0 == VarsComm.CmdSwitchCnt))
        {

          /* Move the inptr ahead */
          IOMapComm.BtInBuf.InPtr = NumberOfBytes;

          /* using the outbuf inptr in order to get the number of bytes in the return answer at the right place*/
          IOMapComm.BtOutBuf.InPtr = NumberOfBytes;

          /* call the data stream interpreter */
          cCommInterprete(IOMapComm.BtInBuf.Buf, IOMapComm.BtOutBuf.Buf, &(IOMapComm.BtOutBuf.InPtr), (UBYTE) BT_CMD_READY, BytesToGo);

          /* if there is a reply to be send then send it */
          if (IOMapComm.BtOutBuf.InPtr)
          {
            dBtSendMsg(IOMapComm.BtOutBuf.Buf, IOMapComm.BtOutBuf.InPtr, IOMapComm.BtOutBuf.InPtr);
            IOMapComm.BtOutBuf.InPtr = 0;
          }
        }
      }
    }
  }
  return(RtnVal);
}

void cCommBtCmdInterpreter(void)
{

  /* this function handles all bluecode commands that can be */
  /* initiated from the outside, meaning from other devices  */
  if(cCommBtValidateCmd())
  {
    switch (IOMapComm.BtInBuf.Buf[BT_CMD_BYTE])
    {
      case MSG_REQUEST_PIN_CODE:
      {

        /* Pass the pin request on to cCommReq it'l handle it */
        cCommReq(PINREQ, 0x00, 0x00, 0x00, NULL, &(VarsComm.RetVal));
      }
      break;

      case MSG_REQUEST_CONNECTION:
      {

        /* Connect request from the outside */
        cCommReq(CONNECTREQ, 0x00, 0x00, 0x00, NULL, &(VarsComm.RetVal));
      }
      break;

      case MSG_LIST_RESULT:
      {
        switch (IOMapComm.BtInBuf.Buf[2])
        {
          case LR_SUCCESS:
          {
          }
          break;
          case LR_ENTRY_REMOVED:
          {
          }
          break;
/*
          case LR_COULD_NOT_SAVE:
          case LR_STORE_IS_FULL:
          case LR_UNKOWN_ADDR:
*/
          default:
          {
            pMapUi->Error           = (UBYTE)IOMapComm.BtInBuf.Buf[2];
            pMapUi->BluetoothState |= BT_ERROR_ATTENTION;
          }
          break;
        }
      }
      break;

      case MSG_CLOSE_CONNECTION_RESULT:
      {
        UBYTE ConnNo;

        for (ConnNo = 0; ConnNo < SIZE_OF_BT_CONNECT_TABLE; ConnNo++)
        {
          if (IOMapComm.BtConnectTable[ConnNo].HandleNr == IOMapComm.BtInBuf.Buf[3])
          {
            IOMapComm.BrickData.BtStateStatus &= ~(BT_CONNECTION_0_ENABLE<<ConnNo);
            CLEARConnEntry(ConnNo);
            ConnNo = SIZE_OF_BT_CONNECT_TABLE;
          }
        }

        if (!(IOMapComm.BrickData.BtStateStatus & (BT_CONNECTION_0_ENABLE | BT_CONNECTION_1_ENABLE | BT_CONNECTION_2_ENABLE | BT_CONNECTION_3_ENABLE)))
        {
          pMapUi->BluetoothState &= ~BT_STATE_CONNECTED;
        }
        pMapUi->Flags |= UI_REDRAW_STATUS;
      }
      break;

      case MSG_PORT_OPEN_RESULT:
      {
        if (IOMapComm.BtInBuf.Buf[2] == 1)
        {
          IOMapComm.BtConnectTable[0].HandleNr = IOMapComm.BtInBuf.Buf[3];
          IOMapComm.BrickData.BtStateStatus   |= BT_BRICK_PORT_OPEN;
        }
        else
        {

          /* There was an error setting up the OpenPort command in BC4 */
          IOMapComm.BtConnectTable[0].HandleNr =  BLUETOOTH_HANDLE_UNDEFIEND;
          IOMapComm.BrickData.BtStateStatus   &= ~BT_BRICK_PORT_OPEN;
        }
      }
      break;

      case MSG_CLOSE_PORT_RESULT:
      {
        if (IOMapComm.BtInBuf.Buf[2] == 1)
        {
          IOMapComm.BtConnectTable[0].HandleNr =  BLUETOOTH_HANDLE_UNDEFIEND;
          IOMapComm.BrickData.BtStateStatus   &= ~BT_BRICK_PORT_OPEN;
        }
      }
      break;

      case MSG_PIN_CODE_ACK:
      {
        pMapUi->BluetoothState &= ~BT_PIN_REQUEST;
      }
      break;

      case MSG_DISCOVERABLE_ACK:
      {
        if (VarsComm.BtCmdData.ParamOne == 1)
        {
          IOMapComm.BrickData.BtStateStatus |= BT_BRICK_VISIBILITY;
          pMapUi->BluetoothState            |= BT_STATE_VISIBLE;
        }
        else
        {
          IOMapComm.BrickData.BtStateStatus &= ~BT_BRICK_VISIBILITY;
          pMapUi->BluetoothState            &= ~BT_STATE_VISIBLE;
        }
      }
      break;
      case MSG_RESET_INDICATION:
      {
        if ((UPD_RESET        != VarsComm.ActiveUpdate) &&
            (UPD_BRICKNAME    != VarsComm.ActiveUpdate) &&
            (UPD_FACTORYRESET != VarsComm.ActiveUpdate))
        {

          /* Not intended reset indication - restart the bluecore */
          if (VarsComm.ActiveUpdate != UPD_IDLE)
          {

            /* Something was ongoing send error message */
            *(VarsComm.pRetVal)  = (UWORD)ERR_COMM_BUS_ERR;
            *(VarsComm.pRetVal) |= 0x8000;
          }

          SETBtStateIdle;
          VarsComm.pRetVal      = &(VarsComm.RetVal);
          VarsComm.ActiveUpdate = UPD_RESET;
        }
      }
      break;
    }
  }
  else
  {
    /* Receive a message with wrong checkSum ! */
  }
}