c_comm.c

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

//
// Date init       14.12.2004
//
// Revision date   $Date:: 16-05-06 9:42                                     $
//
// Filename        $Workfile:: c_comm.c                                      $
//
// Version         $Revision:: 172                                           $
//
// Archive         $Archive:: /LMS2006/Sys01/Main/Firmware/Source/c_comm.c   $
//
// Platform        C
//

#include  "stdconst.h"
#include  "modules.h"
#include  "c_comm.iom"
#include  "c_loader.iom"
#include  "c_ioctrl.iom"
#include  "c_ui.iom"
#include  "c_cmd.iom"
#include  "c_display.iom"
#include  "c_comm.h"
#include  "d_usb.h"
#include  "d_hispeed.h"
#include  "d_bt.h"
#include  <string.h>
#include  <ctype.h>

enum
{
  DEVICE_VERIFIED,
  DEVICE_UPDATED,
  DEVICE_INSERTED
};

#define   DEFAULTBTADR                  "\x00\x16\x53\xFF\xFF\xFF"
#define   BTSTREAMTOUT                  610

#define   LOOKUPNO                      3

#define   CLEARExtMode                  {\
                                          UBYTE Tmp;\
                                          for(Tmp = 0; Tmp < NO_OF_CHANNELS; Tmp++)\
                                          {\
                                            VarsComm.ExtMode[Tmp].Status = FALSE;\
                                          }\
                                        }

#define   CHNumber(Bit)                 (Bit>>1)
#define   SETBtStateIdle                VarsComm.ActiveUpdate   = UPD_IDLE;\
                                        VarsComm.UpdateState    = 0;\
                                        VarsComm.StreamStateCnt = 0;\
                                        VarsComm.CmdSwitchCnt   = 0;\
                                        VarsComm.CloseConn0Cnt  = 0;\
                                        VarsComm.DiscAllCnt     = 0;\
                                        VarsComm.ResetBtCnt     = 0

#define   SETBtCmdState                 VarsComm.BtState           = BT_ARM_CMD_MODE;\
                                        IOMapComm.BtInBuf.InPtr    = 0;\
                                        CLEARExtMode;\
                                        dBtClearArm7CmdSignal();\
                                        dBtInitReceive(VarsComm.BtModuleInBuf.Buf, (UBYTE)CMD_MODE);

#define   SETBtDataState                IOMapComm.BtInBuf.InPtr  = 0;\
                                        VarsComm.BtState         = BT_ARM_DATA_MODE;\
                                        dBtClearTimeOut(); /* stop cmd timeout because in datamode  */\
                                        dBtSetArm7CmdSignal();\
                                        dBtInitReceive(VarsComm.BtModuleInBuf.Buf, (UBYTE)STREAM_MODE)

#define   SETBtOff                      VarsComm.BtState = BT_ARM_OFF;\
                                        dBtSetBcResetPinLow()

#define   CLEARConnEntry(Index)         memset((IOMapComm.BtConnectTable[Index].BdAddr), 0, SIZE_OF_BDADDR);\
                                        memset(IOMapComm.BtConnectTable[Index].Name, 0, SIZE_OF_BT_NAME);\
                                        memset((IOMapComm.BtConnectTable[Index].ClassOfDevice), 0, SIZE_OF_CLASS_OF_DEVICE);\
                                        memset((IOMapComm.BtConnectTable[Index].PinCode), 0, SIZE_OF_BT_PINCODE);\
                                        IOMapComm.BtConnectTable[Index].HandleNr = BLUETOOTH_HANDLE_UNDEFIEND;\
                                        IOMapComm.BtConnectTable[Index].StreamStatus = 0;\
                                        IOMapComm.BtConnectTable[Index].LinkQuality = 0

#define   FILETXTOUT                    30000

const     UBYTE BootString[] = {"Let's dance: SAMBA"};
const     UBYTE NoName[SIZE_OF_BT_NAME] = {"No Name"};

static    IOMAPCOMM  IOMapComm;
static    VARSCOMM   VarsComm;
static    HEADER     **pHeaders;

const     HEADER       cComm =
{
  0x00050001L,
  "Comm",
  cCommInit,
  cCommCtrl,
  cCommExit,
  (void *)&IOMapComm,
  (void *)&VarsComm,
  (UWORD)sizeof(IOMapComm),
  (UWORD)sizeof(VarsComm),
  0x0000                      /* Code size - not used so far */
};

UWORD     cCommReceivedBtData(void);
void      cCommBtCmdInterpreter(void);
UWORD     cCommInterprete(UBYTE *pInBuf, UBYTE *pOutBuf, UBYTE *pLength, UBYTE CmdBit, UWORD MsgLength);
UWORD     cCommInterpreteCmd(UBYTE Cmd, UBYTE *pInBuf, UBYTE *pOutBuf, UBYTE *pLength, UBYTE CmdBit, UWORD MsgLength);
void      cCommCpyToUpper(UBYTE *pDst, UBYTE *pSrc, UBYTE Length);
void      cCommCopyFileName(UBYTE *pDst, UBYTE *pSrc);
void      cCommSendHiSpeedData(void);
void      cCommReceivedHiSpeedData(void);
UWORD     cCommReq(UBYTE Cmd, UBYTE Param1, UBYTE Param2, UBYTE Param3, UBYTE *pName, UWORD *pRetVal);
UBYTE     cCommBtValidateCmd(void);

void      cCommClearStreamStatus(void);
void      cCommUpdateBt(void);
UWORD     cCommCopyBdaddr(UBYTE *pDst, UBYTE *pSrc);
UWORD     cCommInsertBtName(UBYTE *pDst, UBYTE *pSrc);
UWORD     cCommCheckBdaddr(UBYTE *pAdr, UBYTE *pSrc);
UWORD     cCommInsertDevice(UBYTE *pBdaddr, UBYTE *pName, UBYTE *pCod, UBYTE DeviceStatus, UBYTE *pAddInfo);
void      cCommsSetCmdMode(UBYTE *pNextState);
void      cCommsOpenStream(UBYTE *pNextState);
void      cCommsCloseConn0(UBYTE *pNextState);
void      cCommsDisconnectAll(UBYTE *pNextState);
void      cCommsBtReset(UBYTE *pNextState);
void      cCommPinCode(UBYTE *pPinCode);
void      cCommClrConnTable(void);

void      cCommInit(void* pHeader)
{
  UBYTE Tmp;

  pHeaders                   = pHeader;
  IOMapComm.pFunc            = &cCommReq;
  IOMapComm.pFunc2           = &cCommPinCode;
  IOMapComm.UsbState         = FALSE;
  IOMapComm.UsbOutBuf.OutPtr = 0;

  CLEARExtMode;

  dUsbInit();
  dBtInit();

  SETBtStateIdle;
  VarsComm.BtModuleInBuf.InPtr    = 0;
  VarsComm.BtWaitTimeCnt          = 0;

  /* Force a reset sequence on the BC4 */
  VarsComm.pRetVal                = &(VarsComm.RetVal);
  VarsComm.ActiveUpdate           = UPD_RESET;

  VarsComm.BtState                = BT_ARM_CMD_MODE;
  IOMapComm.BrickData.BtHwStatus  = BT_DISABLE;

  for (Tmp = 0; Tmp < SIZE_OF_BT_DEVICE_TABLE; Tmp++)
  {
    IOMapComm.BtDeviceTable[Tmp].DeviceStatus = BT_DEVICE_EMPTY;
  }
  IOMapComm.BtDeviceCnt = 0;
  IOMapComm.BrickData.BtStateStatus = 0;

  cCommClrConnTable();

  dBtInitReceive(VarsComm.BtModuleInBuf.Buf, (UBYTE)CMD_MODE);
  dBtStartADConverter();

  dHiSpeedInit();
  VarsComm.HsState    = 0;

  IOMapComm.UsbPollBuf.InPtr  = 0;
  IOMapComm.UsbPollBuf.OutPtr = 0;

  VarsComm.BtAdrStatus = COLDBOOT;
}

void      cCommCtrl(void)
{

  if (FALSE == cCommReceivedBtData())
  {

    /* there has been a timeout on the BC4 channel */
    SETBtStateIdle;
    *(VarsComm.pRetVal) = BTTIMEOUT;
    if (COLDBOOT == VarsComm.BtAdrStatus)
    {

      /* there is an BT fatal error - set default bt adr and name*/
      strcpy((char*)IOMapComm.BrickData.Name, (char*)UI_NAME_DEFAULT);
      dUsbStoreBtAddress((UBYTE*)DEFAULTBTADR);
      pMapUi->Flags |= UI_REDRAW_STATUS;
      dBtSetBcResetPinLow();
      VarsComm.BtAdrStatus = BTADRERROR;
    }
  }
  cCommUpdateBt();
  VarsComm.BtBcPinLevel = dBtGetBc4CmdSignal();

  if (UPD_IDLE == VarsComm.ActiveUpdate)
  {
    switch (VarsComm.BtState)
    {

      /* Bluetooth device can either be in CMD, DATA or OFF state at top level */
      case BT_ARM_OFF:
      {
      }
      break;
      case BT_ARM_CMD_MODE:
      {
        if (VarsComm.BtBcPinLevel)
        {
          SETBtDataState;
        }
      }
      break;

      case BT_ARM_DATA_MODE:
      {
        if (!(VarsComm.BtBcPinLevel))
        {
          SETBtCmdState;
        }
      }
      break;
    }
  }
  IOMapComm.BtInBuf.Buf[BT_CMD_BYTE] = 0;


  /* Here comes the the HIGHSPEED_PORT implementation */
  if (IOMapComm.HsFlags & HS_UPDATE)
  {
    IOMapComm.HsFlags &= ~HS_UPDATE;
    switch (IOMapComm.HsState)
    {
      case HS_INITIALISE:
      {
        dHiSpeedSetupUart();
        IOMapComm.HsState = HS_INIT_RECEIVER;
        IOMapComm.HsFlags |= HS_UPDATE;
      }
      break;

      case HS_INIT_RECEIVER:
      {
        dHiSpeedInitReceive(VarsComm.HsModuleInBuf.Buf);
        VarsComm.HsState = 0x01;
      }
      break;

      case HS_SEND_DATA:
      {
        cCommSendHiSpeedData();
      }
      break;

      case HS_DISABLE:
      {
        VarsComm.HsState = 0x00;
        dHiSpeedExit();
      }
      break;
    }
  }

  if (VarsComm.HsState != 0)
  {
    cCommReceivedHiSpeedData();
  }

  /* Here comes the the USB implementation */
  ULONG   Length;
  UWORD   Status;

  if (0 != IOMapComm.UsbOutBuf.OutPtr)
  {
    dUsbWrite((const UBYTE *)IOMapComm.UsbOutBuf.Buf, (ULONG)IOMapComm.UsbOutBuf.OutPtr);
    IOMapComm.UsbOutBuf.OutPtr = 0;
  }

  Length = 0;

  if (TRUE == dUsbCheckConnection())
  {
    pMapUi->UsbState = 1;
    if (TRUE == dUsbIsConfigured())
    {
      Length = dUsbRead(IOMapComm.UsbInBuf.Buf, sizeof(IOMapComm.UsbInBuf.Buf));
      IOMapComm.UsbState = TRUE;
      pMapUi->UsbState = 2;
    }
  }
  else
  {
    pMapUi->UsbState = 0;
    dUsbResetConfig();
    if (TRUE == IOMapComm.UsbState)
    {
      IOMapComm.UsbState = FALSE;
      Status =  dUsbGetFirstHandle();
      while(0 == LOADER_ERR(Status))
      {
        IOMapComm.UsbInBuf.Buf[0] = LOADER_HANDLE(Status);
        pMapLoader->pFunc(CLOSE, &(IOMapComm.UsbInBuf.Buf[0]), &(IOMapComm.UsbInBuf.Buf[2]), &Length);
        dUsbRemoveHandle(IOMapComm.UsbInBuf.Buf[0]);
        Status = dUsbGetNextHandle();
      }
    }
  }

  if (0 != Length)
  {
    cCommInterprete(IOMapComm.UsbInBuf.Buf, IOMapComm.UsbOutBuf.Buf, (UBYTE*)&Length, USB_CMD_READY, (UWORD)Length);
    if (Length)
    {
      dUsbWrite((const UBYTE *)IOMapComm.UsbOutBuf.Buf, Length);
    }
  }
  dBtStartADConverter();
}

void      cCommExit(void)
{
  dUsbExit();
  dHiSpeedExit();
  dBtExit();
}

UWORD     cCommInterprete(UBYTE *pInBuf, UBYTE *pOutBuf, UBYTE *pLength, UBYTE CmdBit, UWORD MsgLength)
{
  UWORD   ReturnStatus;
  UBYTE   Channel;

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

    switch (((pInBuf[0]) & ~NO_REPLY_BIT))
    {
      case SYSTEM_CMD:
      {
        ReturnStatus = cCommInterpreteCmd(pInBuf[1], &(pInBuf[1]), &(pOutBuf[2]), pLength, CmdBit, MsgLength);

        /* Check if reply is requested */
        if ((pInBuf[0]) & NO_REPLY_BIT)
        {

          /* Sender has choosen no reply */
          *pLength = 0;

          /* if extended mode then remember the reply bit */
          VarsComm.ExtMode[Channel].Type |= NO_REPLY_BIT;
        }
        else
        {

          /* Check if receiver wants to reply */
          if (*pLength)
          {
            (*pLength)+= 2;
            pOutBuf[0] = REPLY_CMD;
            pOutBuf[1] = pInBuf[1];
          }
        }
      }
      break;

      case DIRECT_CMD:
      {

        /* Adjust length to account for cmd type byte */
        (*pLength) -= 1;

        /* If no reply requested, pass NULL output buffer pointer and clear *pLength */
        if ((pInBuf[0]) & NO_REPLY_BIT)
        {
          pMapCmd->pRCHandler(&(pInBuf[0]), NULL, pLength);
        }
        else
        {
          pMapCmd->pRCHandler(&(pInBuf[0]), &(pOutBuf[2]), pLength);
          if (*pLength)
          {
            (*pLength) += 2;
            pOutBuf[0] = REPLY_CMD;
            pOutBuf[1] = pInBuf[1];
          }
        }
      }
      break;

      case REPLY_CMD:
      {

        /* If this is a reply to a direct command opcode, pRCHandler will handle it */
        if (pInBuf[1] < NUM_RC_OPCODES)
          pMapCmd->pRCHandler(&(pInBuf[0]), NULL, pLength);

        /* No Reply ever required on REPLY_CMD messages */
        *pLength = 0;
      }
      break;

      default:
      {

        /* UNSUPPORTED - don't reply on these messages */
        *pLength = 0;
      }
      break;
    }

  }
  else
  {
    switch (VarsComm.ExtMode[Channel].Type & ~NO_REPLY_BIT)
    {
      case SYSTEM_CMD:
      {
        ReturnStatus = cCommInterpreteCmd(VarsComm.ExtMode[Channel].Cmd, &(pInBuf[0]), &(pOutBuf[2]), pLength, CmdBit, MsgLength);
        if ((VarsComm.ExtMode[Channel].Type) & NO_REPLY_BIT)
        {

          /* Sender has choosen no reply */
          *pLength = 0;
        }
        else
        {

          /* Check if receiver wants to reply */
          if (*pLength)
          {
            (*pLength) += 2;
            pOutBuf[0] = REPLY_CMD;
            pOutBuf[1] = VarsComm.ExtMode[Channel].Cmd;
          }
        }
      }
      break;
      case DIRECT_CMD:
      {
      }
      break;
      case REPLY_CMD:
      {
      }
      break;
      default:
      {
      }
      break;
    }