form_bt.cpp

MTK 手机软件开发 META 源代码,开发环境: C++ Builder

                            sgSendHCI->Cells[HCI_BYTE_COL_IDX][i+1] = IntToStr( iter_par->ui_bytes );
                            AnsiString as_value;
                            if( rbHCIDec->Checked )
                            {
                                BTHCIValue_To_AnsiString( iter_par->s_value, as_value );
                                sgSendHCI->Cells[HCI_VALUE_COL_IDX][i+1] = as_value;
                            }
                            else
                            {

                                BTHCIValue_To_Hex_AnsiString( iter_par->s_value, as_value );
                                sgSendHCI->Cells[HCI_VALUE_COL_IDX][i+1] = as_value;
                            }

                            S_BT_HCI_PARAMETER hci_par;
                           // for( int j=0; j<BT_HCI_VALUE_SIZE; j++ )
                          //  {
                          //      parameter.s_value.uc_value[j] = 0;
                          //  }
                           // parameter.s_value.uc_nz_byte = 0;
                            m_pvSendHCIPar->push_back( parameter );
                        }
                    }

                    // receive parameter
                    if( 0 == iter_cmd->ui_receive_num )
                    {
                        sgReceiveHCI->FixedCols = 3;
                        sgReceiveHCI->FixedRows = 1;
                        sgReceiveHCI->ColCount = 4;
                        sgReceiveHCI->RowCount = 2;
                        sgReceiveHCI->Cells[HCI_NAME_COL_IDX][1] = "";
                        sgReceiveHCI->Cells[HCI_BYTE_COL_IDX][1] = "";
                        sgReceiveHCI->Cells[HCI_VALUE_COL_IDX][1] = "";
                    }
                    else
                    {
                        sgReceiveHCI->FixedCols = 2;
                        sgReceiveHCI->FixedRows = 1;
                        sgReceiveHCI->ColCount = 4;
                       // sgReceiveHCI->RowCount = iter_cmd->ui_receive_num+1;
                        int count = 0;
                        for (unsigned int i=0; i<iter_cmd->ui_receive_num; i++)
                        {
                            iter_par = iter_cmd->v_receive_par.begin() + i;
                            parameter = *iter_par;
                            if( iter_par->b_show )
                            {
                                sgReceiveHCI->Cells[HCI_NAME_COL_IDX][count+1] = iter_par->as_name;
                                sgReceiveHCI->Cells[HCI_BYTE_COL_IDX][count+1] = IntToStr( iter_par->ui_bytes );
                                sgReceiveHCI->Cells[HCI_VALUE_COL_IDX][count+1] = IntToStr( 0 );
                                count++;
                            }
                            for( int j=0; j<BT_HCI_VALUE_SIZE; j++ )
                            {
                                parameter.s_value.uc_value[j] = 0;
                            }
                            parameter.s_value.uc_nz_byte = 0;
                            m_pvReceiveHCIPar->push_back( parameter );
                        }
                        sgReceiveHCI->RowCount = count+1;
                    }

                    break;
                }
            }
        }
    }
    else // group
    {
        if( draw_mask & DRAW_MASK_HCI_GROUP )
        {
            // display group
            cbHCIGroup->Clear();
            for( iter_group = m_pvHCIGroup->begin(); iter_group != m_pvHCIGroup->end(); iter_group++ )
            {
                group = *iter_group;
                cbHCIGroup->Items->Add( group.as_group_name );
            }
            iter_group = m_pvHCIGroup->begin();
            cbHCIGroup->ItemIndex = category_group_idx;
        }

        // display command
        if( draw_mask & DRAW_MASK_HCI_COMMAND )
        {
            for( iter_group = m_pvHCIGroup->begin(); iter_group != m_pvHCIGroup->end(); iter_group++ )
            {
                group = *iter_group;
                if( group.as_group_name.AnsiCompareIC(cbHCIGroup->Text) == 0 )
                {
                    break;
                }
            }

            cbHCICommand->Clear();
            for( iter_cmd = iter_group->v_cmd.begin(); iter_cmd != iter_group->v_cmd.end(); iter_cmd++ )
            {
                command = *iter_cmd;
                cbHCICommand->Items->Add( command.as_cmd_name );
            }
            cbHCICommand->ItemIndex = cmd_idx;
        }

        // display parameter
        if( draw_mask & DRAW_MASK_HCI_PARAMETER )
        {
            // sgSendHCI->EditorMode = true;
            for( iter_cmd = iter_group->v_cmd.begin(); iter_cmd != iter_group->v_cmd.end(); iter_cmd++ )
            {
                command = *iter_cmd;
                if( command.as_cmd_name.AnsiCompareIC(cbHCICommand->Text) == 0 )
                {
                    if( ! m_pvSendHCIPar->empty() )
                    {
                        m_pvSendHCIPar->erase( m_pvSendHCIPar->begin(), m_pvSendHCIPar->end() );
                    }

                    if( ! m_pvReceiveHCIPar->empty() )
                    {
                        m_pvReceiveHCIPar->erase( m_pvReceiveHCIPar->begin(), m_pvReceiveHCIPar->end() );
                    }
                    char str[20];
                    sprintf( str, "%X", iter_cmd->us_opcode );
                    stHCIOpcode->Caption = str;

                    sprintf( str, "%X", iter_cmd->uc_last_event );
                    stHCILastEvent->Caption = str;

                    edtHCITimeout->Text = iter_cmd->ui_ms_timeout;

                    // send parameter
                    if( 0 == iter_cmd->ui_send_num )
                    {
                        sgSendHCI->FixedCols = 3;
                        sgSendHCI->FixedRows = 1;
                        sgSendHCI->ColCount  = 4;
                        sgSendHCI->RowCount  = 2;
                        sgSendHCI->Cells[HCI_NAME_COL_IDX][1] = "";
                        sgSendHCI->Cells[HCI_BYTE_COL_IDX][1] = "";
                        sgSendHCI->Cells[2][1] = "";
                    }
                    else
                    {
                        sgSendHCI->FixedCols = 2;
                        sgSendHCI->FixedRows = 1;
                        sgSendHCI->ColCount = 4;
                        sgSendHCI->RowCount = iter_cmd->ui_send_num+1;
                        for (unsigned int i=0; i<iter_cmd->ui_send_num; i++)
                        {
                            iter_par = iter_cmd->v_send_par.begin() + i;
                            parameter = *iter_par;
                            sgSendHCI->Cells[HCI_NAME_COL_IDX][i+1] = iter_par->as_name;
                            sgSendHCI->Cells[HCI_BYTE_COL_IDX][i+1] = IntToStr( iter_par->ui_bytes );
                            AnsiString as_value;
                            if( rbHCIDec->Checked )
                            {
                                BTHCIValue_To_AnsiString( iter_par->s_value, as_value );
                                sgSendHCI->Cells[HCI_VALUE_COL_IDX][i+1] = as_value;
                            }
                            else
                            {
                                BTHCIValue_To_Hex_AnsiString( iter_par->s_value, as_value );
                                sgSendHCI->Cells[HCI_VALUE_COL_IDX][i+1] = as_value;
                            }
                           // for( int j=0; j<BT_HCI_VALUE_SIZE; j++ )
                           // {
                           ////     parameter.s_value.uc_value[j] = 0;
                           // }
                           // parameter.s_value.uc_nz_byte = 0;
                            m_pvSendHCIPar->push_back( parameter );
                        }
                    }

                    // receive parameter
                    if( 0 == iter_cmd->ui_receive_num )
                    {
                        sgReceiveHCI->FixedCols = 3;
                        sgReceiveHCI->FixedRows = 1;
                        sgReceiveHCI->ColCount = 4;
                        sgReceiveHCI->RowCount = 2;
                        sgReceiveHCI->Cells[HCI_NAME_COL_IDX][1] = "";
                        sgReceiveHCI->Cells[HCI_BYTE_COL_IDX][1] = "";
                        sgReceiveHCI->Cells[HCI_VALUE_COL_IDX][1] = "";
                    }
                    else
                    {
                        sgReceiveHCI->FixedCols = 2;
                        sgReceiveHCI->FixedRows = 1;
                        sgReceiveHCI->ColCount = 4;
                       // sgReceiveHCI->RowCount = iter_cmd->ui_receive_num+1;
                        int count = 0;
                        for (unsigned int i=0; i<iter_cmd->ui_receive_num; i++)
                        {
                            iter_par = iter_cmd->v_receive_par.begin() + i;
                            parameter = *iter_par;
                            if( iter_par->b_show )
                            {
                                sgReceiveHCI->Cells[HCI_NAME_COL_IDX][count+1] = iter_par->as_name;
                                sgReceiveHCI->Cells[HCI_BYTE_COL_IDX][count+1] = IntToStr( iter_par->ui_bytes );
                                sgReceiveHCI->Cells[HCI_VALUE_COL_IDX][count+1] = IntToStr( 0 );
                                count++;
                            }

                            for( int j=0; j<BT_HCI_VALUE_SIZE; j++ )
                            {
                                parameter.s_value.uc_value[j] = 0;
                            }
                            parameter.s_value.uc_nz_byte = 0;
                            m_pvReceiveHCIPar->push_back( parameter );
                        }
                        sgReceiveHCI->RowCount = count+1;
                    }

                    break;
                }
            }
        }
    }
}

//---------------------------------------------------------------------------
void  TfrmBT::DisplayHCIFile( void )
{
    AnsiString as_HCI_file = read_HCI_File("MF_setup.txt", Application->ExeName);
    ReadHCIFile( as_HCI_file );
}

//---------------------------------------------------------------------------
void  TfrmBT::SaveHCIFile( void )
{
    if( stHCIFile->Caption.AnsiCompareIC("") != 0 )
    {    write_HCI_File( "MF_setup.txt", Application->ExeName, stHCIFile->Caption );
    }
}

//---------------------------------------------------------------------------
void TfrmBT::ReadHCIFile( AnsiString asFileName )
{
    if( ! CheckFileExist(asFileName) )
    {
        return;
    }

    m_sBTHCI.hPostMsgDestHandle = this->Handle;
    m_sBTHCI.filename           = asFileName;
    m_sBTHCI.log                = m_pHCILog;
   // m_BT_HCI_Obj.ConfirmCallback = ::ConfirmCallback_SetupHCIFile;
   // m_BT_HCI_Obj.REQ_Read_From_File_Start( m_sBTHCI );
    bool ok = m_BT_HCI_Obj.REQ_Read_Last_HCI_File_Start( m_sBTHCI );
    if( ok )
    {
        stHCIFile->Caption = m_sBTHCI.filename;
        if( rbHCICategory->Checked )
        {
            m_pvHCICategory = m_BT_HCI_Obj.Get_HciCategoryVector();
            DisplayHCIUI( DRAW_MASK_HCI_CATEGORY | DRAW_MASK_HCI_COMMAND | DRAW_MASK_HCI_PARAMETER, 0, 0 );
        }
        else
        {
            m_pvHCIGroup = m_BT_HCI_Obj.Get_HciGroupVector();
            DisplayHCIUI( DRAW_MASK_HCI_GROUP | DRAW_MASK_HCI_COMMAND | DRAW_MASK_HCI_PARAMETER, 0, 0 );
        }
        sbHCI->Panels->Items[0]->Text = (AnsiString)"  Setup HCI file successfully";
    }

}

//--------------------------------------------------------------------------
bool TfrmBT::ComposeHCICommand( S_BT_HCI &hci )
{
    S_BT_HCI_VALUE s_value;
    //unsigned char parameter_len=0;
    int row, byte_idx, str_idx;
    int value;
  //  char value_str[256];
    int byte_num;
    int hci_cmd_max_len;
    hci_cmd_max_len = sizeof(hci.s_hci_cmd.m_cmd)/sizeof(hci.s_hci_cmd.m_cmd[0]);
    for( int i=0; i<hci_cmd_max_len; i++ )
        hci.s_hci_cmd.m_cmd[i] = '\0';

    // opcode
    if( ! IsValidHexBTHCIOpcode( stHCIOpcode->Caption, hci.s_hci_cmd.m_opcode ) )
        return false;

    // last event index
    if( ! IsValidHexBTHCIEventIndex( stHCILastEvent->Caption, hci.uc_last_event ) )
        return false;

   // hci.s_hci_cmd.m_cmd[0] = hci.s_hci_cmd.m_opcode & 0x00FF ;
   // hci.s_hci_cmd.m_cmd[1] = (hci.s_hci_cmd.m_opcode & 0xFF00)>>8 ;

    // parameter length
   // for( row=1; row<sgSendHCI->RowCount; row++ )
   // {
   //     parameter_len += sgSendHCI->Cells[HCI_BYTE_COL_IDX][row].ToInt();
   // }
   // hci.s_hci_cmd.m_cmd[2] = parameter_len;

    // parameter
    hci.s_hci_cmd.m_len = 0;
    for( row=1; row<sgSendHCI->RowCount; row++ )
    {
        if( sgSendHCI->Cells[HCI_BYTE_COL_IDX][row].AnsiCompareIC("") == 0 )
            return true;
        byte_num = sgSendHCI->Cells[HCI_BYTE_COL_IDX][row].ToInt();
        if( rbHCIHex->Checked )
        {
            AnsiString_Hex_To_BTHCIValue( sgSendHCI->Cells[HCI_VALUE_COL_IDX][row], s_value );
            //itoa( value, value_str, 10 );
        }
        else
        {
            AnsiString_To_BTHCIValue( sgSendHCI->Cells[HCI_VALUE_COL_IDX][row], s_value );
        }
       // for( str_idx=0; str_idx<hci_cmd_max_len; str_idx++ )
       // {
       //     if(  0 == value_str[str_idx] )
       //     {
       //        value_str_len = str_idx;
       //        break;
       //     }
       // }

        for( byte_idx=0; byte_idx<byte_num; byte_idx++ )
        {
            if( byte_idx < s_value.uc_nz_byte )
            {
                hci.s_hci_cmd.m_cmd[hci.s_hci_cmd.m_len] = s_value.uc_value[byte_idx];
            }
            else
            {   hci.s_hci_cmd.m_cmd[hci.s_hci_cmd.m_len] = 0;
            }
            hci.s_hci_cmd.m_len++;
        }
    }

    return true;
}

//--------------------------------------------------------------------------
bool  TfrmBT::DeComposeHCIEvent( BT_HCI_EVENT &event )
{
    if( sgReceiveHCI->Cells[HCI_NAME_COL_IDX][1].AnsiCompareIC("") == 0 )  // no event parameter
         return true;

    static vector<S_BT_HCI_CATEGORY>:: iterator iter_category;
    static vector<S_BT_HCI_GROUP>:: iterator iter_group;
    vector<S_BT_HCI_COMMAND>:: iterator iter_cmd;
    vector<S_BT_HCI_PARAMETER>:: iterator iter_par;
    S_BT_HCI_PARAMETER sParameter;
   // int row;
//     vector<S_BT_HCI_PARAMETER>:: iterator iter_par;
     int idx = 0;


     if( ! m_pvReceiveHCIPar->empty() )
     {
         m_pvReceiveHCIPar->erase(m_pvReceiveHCIPar->begin(), m_pvReceiveHCIPar->end() );
     }


   // S_BT_HCI_CATEGORY category;
   // S_BT_HCI_GROUP group;
   // S_BT_HCI_COMMAND command;
   // S_BT_HCI_PARAMETER parameter;

    if( rbHCICategory->Checked )
    {
        for( iter_category = m_pvHCICategory->begin(); iter_category != m_pvHCICategory->end(); iter_category++ )
        {
            AnsiString as_category_name = iter_category->as_category_name.Trim();
            AnsiString as_text = cbHCICategory->Text.Trim();
            if( as_category_name.AnsiCompareIC(as_text) == 0 )
                break;
        }