c_comm.c

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

  }

  return(ReturnStatus);
}


UWORD     cCommInterpreteCmd(UBYTE Cmd, UBYTE *pInBuf, UBYTE *pOutBuf, UBYTE *pLength, UBYTE CmdBit, UWORD MsgLength)
{
  ULONG   FileLength;
  UWORD   Status;
  UBYTE   Channel;

  Channel = CHNumber(CmdBit);
  switch(Cmd)
  {
    case OPENWRITE:
    {
      UBYTE TmpFilename[FILENAME_LENGTH + 1];

      FileLength  = pInBuf[21];
      FileLength += (ULONG)pInBuf[22] << 8;
      FileLength += (ULONG)pInBuf[23] << 16;
      FileLength += (ULONG)pInBuf[24] << 24;

      cCommCpyToUpper(TmpFilename, &pInBuf[1], (UBYTE)(FILENAME_LENGTH + 1));

      if ((0 != strstr((PSZ)(TmpFilename), ".RXE")) ||
          (0 != strstr((PSZ)(TmpFilename), ".SYS")) ||
          (0 != strstr((PSZ)(TmpFilename), ".RTM")))
      {
        Status = pMapLoader->pFunc(OPENWRITELINEAR, &pInBuf[1], NULL, &FileLength);
      }
      else
      {
        Status = pMapLoader->pFunc(OPENWRITE, &pInBuf[1], NULL, &FileLength);
      }
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);
      *pLength = 2;
      if ((SUCCESS == LOADER_ERR(Status)) && (CmdBit & USB_CMD_READY))
      {
        dUsbInsertHandle(LOADER_HANDLE(Status));
      }
    }
    break;
    case WRITE:
    {

      if (FALSE == VarsComm.ExtMode[Channel].Status)
      {

        FileLength = *pLength - 3;
        Status = pMapLoader->pFunc(WRITE, &(pInBuf[1]), &(pInBuf[2]), &FileLength);
        pOutBuf[2] = (UBYTE)(FileLength);
        pOutBuf[3] = (UBYTE)(FileLength >> 8);
        if ((*pLength != MsgLength) && (MsgLength != 0))
        {

          /* This is the beginnig of and extended write command*/
          VarsComm.ExtMode[Channel].Cmd    = WRITE;
          VarsComm.ExtMode[Channel].Type   = SYSTEM_CMD;
          VarsComm.ExtMode[Channel].Status = TRUE;
          VarsComm.ExtMode[Channel].Handle = LOADER_HANDLE(Status);
          *pLength = 0;
        }
        else
        {

          /* Normal write */
          pOutBuf[0] = LOADER_ERR_BYTE(Status);
          pOutBuf[1] = LOADER_HANDLE(Status);
          *pLength   = 4;
        }
      }
      else
      {
        UWORD TmpLen;
        FileLength = *pLength;
        Status = pMapLoader->pFunc(WRITE, &(VarsComm.ExtMode[Channel].Handle), &(pInBuf[0]), &FileLength);
        TmpLen     = pOutBuf[3];
        TmpLen   <<= 8;
        TmpLen    |= pOutBuf[2];
        TmpLen    += FileLength;
        pOutBuf[2] = (UBYTE)(TmpLen);
        pOutBuf[3] = (UBYTE)(TmpLen >> 8);
        if (MsgLength)
        {

          /* Don't answer before complete message has been received */
          *pLength = 0;
        }
        else
        {

          /* Complete msg has been received */
          VarsComm.ExtMode[Channel].Status = FALSE;
          pOutBuf[0] = LOADER_ERR_BYTE(Status);
          pOutBuf[1] = LOADER_HANDLE(Status);
          *pLength   = 4;  /* Remember the 2 length bytes */

        }
      }

    }
    break;
    case OPENWRITEDATA:
    {
      FileLength  = pInBuf[21];
      FileLength += (ULONG)pInBuf[22] << 8;
      FileLength += (ULONG)pInBuf[23] << 16;
      FileLength += (ULONG)pInBuf[24] << 24;

      Status = pMapLoader->pFunc(OPENWRITEDATA, &pInBuf[1], NULL, &FileLength);

      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);
      *pLength = 2;
      if ((SUCCESS == LOADER_ERR(Status)) && (CmdBit & USB_CMD_READY))
      {
        dUsbInsertHandle(LOADER_HANDLE(Status));
      }
    }
    break;
    case OPENAPPENDDATA:
    {
      Status = pMapLoader->pFunc(OPENAPPENDDATA, &pInBuf[1], NULL, &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);

      pOutBuf[2] = (UBYTE)FileLength;
      pOutBuf[3] = (UBYTE)(FileLength >> 8);
      pOutBuf[4] = (UBYTE)(FileLength >> 16);
      pOutBuf[5] = (UBYTE)(FileLength >> 24);
      *pLength = 6;
      if ((SUCCESS == LOADER_ERR(Status)) && (CmdBit & USB_CMD_READY))
      {
        dUsbInsertHandle(LOADER_HANDLE(Status));
      }
    }
    break;
    case CLOSE:
    {
      if (CmdBit & USB_CMD_READY)
      {
        dUsbRemoveHandle(pInBuf[1]);
      }
      Status = pMapLoader->pFunc(CLOSE, &(pInBuf[1]), NULL, &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);
      *pLength = 2;
    }
    break;
    case OPENREAD:
    {
      Status = pMapLoader->pFunc(OPENREAD, &pInBuf[1], NULL, &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);
      pOutBuf[2] = (UBYTE)FileLength;
      pOutBuf[3] = (UBYTE)(FileLength >> 8);
      pOutBuf[4] = (UBYTE)(FileLength >> 16);
      pOutBuf[5] = (UBYTE)(FileLength >> 24);
      *pLength = 6;
      if ((SUCCESS == LOADER_ERR(Status)) && (CmdBit & USB_CMD_READY))
      {
        dUsbInsertHandle(LOADER_HANDLE(Status));
      }
    }
    break;
    case READ:
    {
      ULONG Length;

      FileLength   = pInBuf[3];
      FileLength <<= 8;
      FileLength  |= pInBuf[2];
      Length       = FileLength;

      /* Here test for channel - USB can only handle a 64 byte return (- wrapping )*/
      if (CmdBit & USB_CMD_READY)
      {
        if (FileLength > (SIZE_OF_USBBUF - 6))
        {

          /* Buffer cannot hold the requested data adjust to buffer size */
          FileLength = (SIZE_OF_USBBUF - 6);
        }
        *pLength   = FileLength + 4;
        Status     = pMapLoader->pFunc(READ, &pInBuf[1], &pOutBuf[4], &FileLength);
        pOutBuf[0] = LOADER_ERR_BYTE(Status);
        pOutBuf[1] = LOADER_HANDLE(Status);
        pOutBuf[2] = (UBYTE)Length;
        pOutBuf[3] = (UBYTE)(Length >> 8);

        if (FileLength < Length)
        {

          /* End of file is detcted - add up with zeros to the requested msg length */
          Length -= FileLength;
          memset(&(pOutBuf[(FileLength + 4)]),0x00,Length);
        }
      }
      else
      {

        /* This is a BT request - BT can handle large packets */
        if (FileLength > (SIZE_OF_BTBUF - 6))
        {

          /* Read length exceeds buffer length check for extended read back */
          if (SUCCESS == cCommReq(EXTREAD, 0x00, 0x00, 0x00, NULL, &(VarsComm.RetVal)))
          {

            /* More data requested than buffer can hold .... go into extended mode */
            VarsComm.ExtTx.RemMsgSize = FileLength;
            VarsComm.ExtTx.SrcHandle  = pInBuf[1];
            VarsComm.ExtTx.Cmd        = READ;
            *pLength                  = 0;
          }
          else
          {

            /* We were not able to go into extended mode bt was busy */
            /* for now do not try to reply as it is not possible to  */
            /* return the requested bytes                            */
            *pLength = 0;
          }
        }
        else
        {

          *pLength   = FileLength + 4;
          Status     = pMapLoader->pFunc(READ, &pInBuf[1], &pOutBuf[4], &FileLength);
          pOutBuf[0] = LOADER_ERR_BYTE(Status);
          pOutBuf[1] = LOADER_HANDLE(Status);
          pOutBuf[2] = (UBYTE)Length;
          pOutBuf[3] = (UBYTE)(Length >> 8);

          if (FileLength < Length)
          {

            /* End of file is detcted - add up with zeros to the requested msg length */
            Length -= FileLength;
            memset(&(pOutBuf[(FileLength + 4)]),0x00,Length);
          }
        }
      }
    }
    break;
    case DELETE:
    {
      Status = pMapLoader->pFunc(DELETE, &pInBuf[1], NULL, &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      cCommCopyFileName(&pOutBuf[1], &pInBuf[1]);
      *pLength = FILENAME_LENGTH + 1 + 1; /*Filemname + 0 terminator + error byte */
    }
    break;
    case FINDFIRST:
    {
      Status = pMapLoader->pFunc(FINDFIRST, &(pInBuf[1]), &(pOutBuf[2]), &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);
      if (LOADER_ERR_BYTE(SUCCESS) == pOutBuf[0])
      {
        pOutBuf[22] = (UBYTE)FileLength;
        pOutBuf[23] = (UBYTE)(FileLength >> 8);
        pOutBuf[24] = (UBYTE)(FileLength >> 16);
        pOutBuf[25] = (UBYTE)(FileLength >> 24);
        if (CmdBit & USB_CMD_READY)
        {
          dUsbInsertHandle(pOutBuf[1]);
        }
      }
      else
      {

        /* ERROR - Fill with zeros */
        memset(&(pOutBuf[2]),0x00,24);
      }

      *pLength = 26;
    }
    break;
    case FINDNEXT:
    {
      Status = pMapLoader->pFunc(FINDNEXT, &(pInBuf[1]), &(pOutBuf[2]), &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);
      if (LOADER_ERR_BYTE(SUCCESS) == pOutBuf[0])
      {
        pOutBuf[22] = (UBYTE)FileLength;
        pOutBuf[23] = (UBYTE)(FileLength >> 8);
        pOutBuf[24] = (UBYTE)(FileLength >> 16);
        pOutBuf[25] = (UBYTE)(FileLength >> 24);
      }
      else
      {

        /* ERROR - Fill with zeros */
        memset(&(pOutBuf[2]),0x00,24);
      }
      *pLength = 26;
    }
    break;
    case OPENREADLINEAR:
    {

      /* For internal use only */
    }
    break;
    case VERSIONS:
    {
      pOutBuf[0] = LOADER_ERR_BYTE(SUCCESS);
      pOutBuf[1] = (UBYTE)PROTOCOLVERSION;
      pOutBuf[2] = (UBYTE)(PROTOCOLVERSION>>8);
      pOutBuf[3] = (UBYTE)FIRMWAREVERSION;
      pOutBuf[4] = (UBYTE)(FIRMWAREVERSION>>8);
      *pLength = 5;
    }
    break;
    case OPENWRITELINEAR:
    {
      FileLength  = pInBuf[21];
      FileLength += (ULONG)pInBuf[22] << 8;
      FileLength += (ULONG)pInBuf[23] << 16;
      FileLength += (ULONG)pInBuf[24] << 24;
      Status = pMapLoader->pFunc(OPENWRITELINEAR, &pInBuf[1], NULL, &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = LOADER_HANDLE(Status);
      *pLength = 2;
      if ((SUCCESS == LOADER_ERR(Status)) && (CmdBit & USB_CMD_READY))
      {
        dUsbInsertHandle(LOADER_HANDLE(Status));
      }
    }
    break;
    case FINDFIRSTMODULE:
    {
      Status = pMapLoader->pFunc(FINDFIRSTMODULE, &pInBuf[1], &pOutBuf[2], &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = 0;

      if (LOADER_ERR_BYTE(SUCCESS) != pOutBuf[0])
      {
        memset(&pOutBuf[2], 0x00, 30);
      }
      *pLength = 32;
    }
    break;

    case FINDNEXTMODULE:
    {
      Status = pMapLoader->pFunc(FINDNEXTMODULE, pInBuf, &pOutBuf[2], &FileLength);
      pOutBuf[0] = LOADER_ERR_BYTE(Status);
      pOutBuf[1] = 0;

      if (LOADER_ERR_BYTE(SUCCESS) != pOutBuf[0])
      {
        memset(&pOutBuf[2], 0x00, 30);
      }
      *pLength = 32;
    }
    break;

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

    case IOMAPREAD:
    {
      ULONG ModuleId;
      UWORD Length;

      ModuleId     = pInBuf[1];
      ModuleId    |= (ULONG)pInBuf[2] << 8;
      ModuleId    |= (ULONG)pInBuf[3] << 16;
      ModuleId    |= (ULONG)pInBuf[4] << 24;

      /* Transfer the Module id */
      pOutBuf[1]   = pInBuf[1];
      pOutBuf[2]   = pInBuf[2];
      pOutBuf[3]   = pInBuf[3];
      pOutBuf[4]   = pInBuf[4];

      /* Transfer the offset into the iomap (pOutBuf[6] is intended...)*/
      pOutBuf[5]   = pInBuf[5];
      pOutBuf[6]   = pInBuf[6];

      /* Get the read *pLength */
      FileLength   = pInBuf[8];
      FileLength <<= 8;
      FileLength  |= pInBuf[7];

      if (CmdBit & USB_CMD_READY)
      {

        /* test for USB buffer overrun */
        if (FileLength > (SIZE_OF_USBBUF - 9))
        {
          FileLength = SIZE_OF_USBBUF - 9;
        }
      }
      else
      {

        /* test for BT buffer overrun */
        if (FileLength > (SIZE_OF_BTBUF - 9))
        {
          FileLength = SIZE_OF_BTBUF - 9;
        }
      }

      Length   = FileLength;
      *pLength = Length + 7;
      Status = pMapLoader->pFunc(IOMAPREAD, (UBYTE *)&ModuleId, &pOutBuf[5], &FileLength);

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

      if (Length > FileLength)
      {
        Length -= FileLength;
        memset(&(pOutBuf[FileLength + 7]), 0x00, Length);
      }
    }
    break;

    case IOMAPWRITE:
    {
      ULONG ModuleId;

      pOutBuf[1]  = pInBuf[1];
      pOutBuf[2]  = pInBuf[2];
      pOutBuf[3]  = pInBuf[3];
      pOutBuf[4]  = pInBuf[4];

      ModuleId  = pInBuf[1];
      ModuleId |= (ULONG)pInBuf[2] << 8;
      ModuleId |= (ULONG)pInBuf[3] << 16;
      ModuleId |= (ULONG)pInBuf[4] << 24;

      FileLength   = pInBuf[8];
      FileLength <<= 8;
      FileLength  |= pInBuf[7];

      /* Place offset right before data */
      pInBuf[8] = pInBuf[6];
      pInBuf[7] = pInBuf[5];