hostcontrolinterface.cpp

蓝牙芯片ZV4301的调试工具源码.做蓝牙产品时很有参考价值内部有串口的编程序源码,对有串口编成需求的同志有参考价值.

#include <stdio.h>
#include <string.h>
#include "HostControlInterface.h"
#include "HCI_DEBUG.h"
/*******************************************************************************
*         OPCODE - OCF & OGF function
*******************************************************************************/
static unsigned __int8 INTERFACE_HEAD[] = {UART_TL_HEAD_HCI_CMD};

#define PACKET_HCI_OP_CODE(_OGF,_OCF)   ((unsigned __int16)_OGF << 10 | (unsigned __int16)_OCF)
Topcode::Topcode(unsigned __int8 OGF, unsigned __int8 OCF)
{
  _ocf = OCF;
  _ogf = OGF;
  _opcode = PACKET_HCI_OP_CODE(_ocf, _ogf);
}

Topcode::Topcode(unsigned __int16 OPCODE)
{
  SetOPCODE(OPCODE);
}

Topcode::Topcode(void)
{
  SetOPCODE(0x0000);
}

Topcode::~Topcode()
{
  //Do nothing
}

void __fastcall Topcode::SetOPCODE(unsigned __int16 OPCODE)
{
  _opcode = OPCODE;
  _ogf = _opcode >> 10;
  _ocf = _opcode & 0x03FF;
}

void __fastcall Topcode::SetOCF(unsigned __int8 OCF)
{
  _ocf = OCF;
  _opcode = PACKET_HCI_OP_CODE(_ogf, _ocf);
}
void __fastcall Topcode::SetOGF(unsigned __int8 OGF)
{
  _ogf = OGF;
  _opcode = PACKET_HCI_OP_CODE(_ogf, _ocf);
}

/*******************************************************************************
*         THci Object
*******************************************************************************/
Thci_command::Thci_command(unsigned __int8 OGF, unsigned __int8 OCF, Thci_param *PARAM)
{
  opcode.ocf = OCF;
  opcode.ogf = OGF;
  if(PARAM)
    memcpy(&param, PARAM, sizeof(Thci_param));
  else
    memset(&param, 0, sizeof(Thci_param));
}
Thci_command::Thci_command(unsigned __int16 OPCODE, Thci_param *PARAM)
{
  opcode.opcode = OPCODE;
  if(PARAM)
    memcpy(&param, PARAM, sizeof(Thci_param));
  else
    memset(&param, 0, sizeof(Thci_param));
}

Thci_command::Thci_command(void)
{
  memset(&param, 0, sizeof(Thci_param));
}

Thci_command::~Thci_command()
{
}

//Utilities
int Thci_command::MakeCommand(TCommInterface transport, unsigned char *buff, int real_buff_size)
{
  int cmd_size = 1 + 2 + 1 + param._len;
  unsigned __int8 intbuff[259];
  _DEBUG_STRING _debug;
  memset(intbuff, 259, 0);

  //Put Header to indicate the Transport
  intbuff[0] = INTERFACE_HEAD[transport];
  //Put opcode
  memcpy(&intbuff[1], &(opcode.opcode), sizeof(unsigned __int16));
  //Put Parameter length
  intbuff[3] = param._len;
  //Put Param
  memcpy(&intbuff[4], param._data, param._len);

  DebugPrintf("         UART TL Header:   [1] %02X", INTERFACE_HEAD[transport]);
  DebugPrintf("         OpCode:           [2] %04X", opcode.opcode);
  DebugPrintf("                           OGF: %02X - %s",opcode.ogf, _debug.OGF[opcode.ogf]);
  DebugPrintf("                           OCF: %02X - %s",opcode.ocf, _debug.OCF[opcode.ogf][opcode.ocf]);
  DebugPrintf("         Parameter Length: [1] %02X - %d Bytes", param._len, param._len);
  if(real_buff_size > cmd_size)
  {
    memcpy(buff, intbuff, cmd_size);
    return cmd_size;
  }
  else
    return 0;
}


/******************************************************************************
*   HCI EVENT
*******************************************************************************/
Thci_event::Thci_event(void)
{
  memset(_bin, 0, 512);
  _binbytes = 0;
  ON_HCI_EVT_ZEEVO_PRINT = NULL;
}

bool __fastcall Thci_event::Input(unsigned __int8 *pData, unsigned __int16 len)
{
//  if((len + _binbytes) > MAX_HCI_EVENT_DATA)
//    return false;
  if(_binbytes + len > MAX_EVENT_BUFF)
    DebugPrintf("NOT ENOUGH BUFFER TO PARSE EVENT");


  if(!pData)
    return false;

  memcpy(&_bin[_binbytes], pData, len);
  _binbytes += len;
  return true;
}

void __fastcall Thci_event::Clear(void)
{
  memset(_bin, 0, 512);
  _binbytes = 0;
}

void __fastcall Thci_event::ClearInValid(void)
{
  int shift = 0;
  for(int i=0; i<_binbytes; i++)
    if(_bin[i] == 0x04)
      shift = i;
  if(shift == 0)
    Clear();
  else
  {
    _binbytes -= shift;
    memcpy(&_bin[0], &_bin[shift], _binbytes);
    DebugPrintf("Shift Data To %d-th Byte", shift);
  }
}

_EVT_RESULT __fastcall Thci_event::ParseEvent(void)
{
  _DEBUG_STRING debug;

  if(_binbytes < 3)
    return EVT_NEEDMOREDATA;

    _data._tl = _bin[0];
    _data._event = _bin[1];
    _data._paramlen = _bin[2];

  if(_data._paramlen == _binbytes - 3)
  {
    memset(_data._param, 0, 256);
    memcpy(_data._param, &_bin[3], _data._paramlen);
    if(_data._event != HCI_EVENT_ZEEVO_EVENT)
    {
      DebugPrintf("         UART Tl Header:   [1] %02X", _data._tl);
      DebugPrintf("         Event Code:       [1] %02X - %s", _data._event, debug.EVENT[_data._event]);
      DebugPrintf("         ParamLen:         [1] %02X - %d Bytes", _data._paramlen, _data._paramlen);
    }
    switch(_data._event){
      case HCI_EVENT_CMD_COMPLETE:
        HANDLE_CMD_COMPLETE();
        break;
      case HCI_EVENT_ZEEVO_EVENT:
        HANDLE_ZEEVO_EVENT();
        break;
    }
  }
  else if(_data._paramlen > _binbytes - 3)
  {
    DebugPrintf("Need more data to parse event...");
    return EVT_NEEDMOREDATA;
  }
  else if(_data._paramlen < _binbytes - 3)
  {
    memset(_data._param, 0, 256);
    memcpy(_data._param, &_bin[3], _data._paramlen);
    if(_data._event != HCI_EVENT_ZEEVO_EVENT)
    {
      DebugPrintf("         UART Tl Header:   [1] %02X", _data._tl);
      DebugPrintf("         Event Code:       [1] %02X - %s", _data._event, debug.EVENT[_data._event]);
      DebugPrintf("         ParamLen:         [1] %02X - %d Bytes", _data._paramlen, _data._paramlen);
    }
    switch(_data._event){
      case HCI_EVENT_CMD_COMPLETE:
        HANDLE_CMD_COMPLETE();
        break;
      case HCI_EVENT_ZEEVO_EVENT:
        HANDLE_ZEEVO_EVENT();
        break;
    }


    if(_bin[_data._paramlen+3] != 0x04)
      ClearInValid();
    else
    {
      _binbytes = _binbytes - (_data._paramlen+3);
      memcpy(&_bin[0], &_bin[_data._paramlen+3], _binbytes);
    }
    //ParseEvent();
    return EVT_MOREDATA;
  }
  return EVT_INVALID;
}

_EVT_RESULT __fastcall Thci_event::ParseEvent(unsigned __int8 *pData, unsigned __int16 len)
{
  if(!Input(pData, len))
  {
    DebugPrintf("Not valid event...");
    return EVT_INVALID;
  }
  return ParseEvent();
}

void __fastcall Thci_event::HANDLE_CMD_COMPLETE(void)
{
  _DEBUG_STRING debug;
  unsigned __int16 opcode;
  Thci_evt_cmd_complete event_data;
  event_data.packet_number = _data._param[0];
  memcpy(&opcode, &_data._param[1], sizeof(unsigned __int16));
  event_data.opcode.opcode = opcode;
  DebugPrintf("Event Command Complete:");
  DebugPrintf("         Num of packets:   [1] %02X", event_data.packet_number);
  DebugPrintf("         OpCode:           [2] %04X", event_data.opcode.opcode);
  DebugPrintf("                           OGF: %02X - %s",event_data.opcode.ogf, debug.OGF[event_data.opcode.ogf]);
  DebugPrintf("                           OCF: %02X - %s",event_data.opcode.ocf, debug.OCF[event_data.opcode.ogf][event_data.opcode.ocf]);

  if(event_data.opcode.ogf == OGF_HOST_CONTROLLER_BASEBAND_COMMAND)
  {
    switch(event_data.opcode.ocf){
      case OCF_RESET:
        Thci_evt_cmd_complete_reset reset;
        reset.status = _data._param[3];
        DebugPrintf("         Status:           [1] %02X - %s",reset.status, debug.ERR[reset.status]);
        break;
      case OCF_READ_LOCAL_NAME:
        Thci_evt_cmd_complete_readlocalname readlocalname;
        readlocalname.status = _data._param[3];
        memset(readlocalname.localname, 0, 256);
        memcpy(readlocalname.localname, &_data._param[4], _data._paramlen - 4);
        DebugPrintf("         Status:           [1] %02X - %s",readlocalname.status, debug.ERR[readlocalname.status]);
        DebugPrintf("         Local Name:       [%d] %s",strlen(readlocalname.localname), readlocalname.localname);
        break;
    }
  }
  else if(event_data.opcode.ogf == OGF_INFOMATION_PARAMETERS)
  {
    switch(event_data.opcode.ocf){
      case OCF_READ_LOCAL_VERSION:
        Thci_evt_cmd_complete_readlocalver localver;
        localver.status = _data._param[3];
        DebugPrintf("         Status:           [1] %02X - %s",localver.status, debug.ERR[localver.status]);
        break;
    }
  }
}

void __fastcall Thci_event::HANDLE_ZEEVO_EVENT(void)
{
  _DEBUG_STRING debug;
  Thci_evt_zeevo_event event_data;
  event_data.code = _data._param[0];
  //DebugPrintf("         Zeevo Event Code: [%d] %s",event_data.code, debug.ZV_EVT[event_data.code]);
  switch(event_data.code){
    case ZEEVI_EVENT_PRINT:
        Thci_evt_zeevo_event_print print;
        strcpy(print.value, &_data._param[1]);
        //DebugPrintf("Zeevo Print: %s",print.value);
        if(ON_HCI_EVT_ZEEVO_PRINT)
          ON_HCI_EVT_ZEEVO_PRINT(&print);
      break;
  }
}