form_wifialc2400m.cpp

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

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#ifndef  _METAAPP_COMMON_H_
#include "METAAPP_common.h"
#endif

#ifndef _FORM_WIFIALC2400M_H_
#include "form_WiFiALC2400M.h"
#endif

#ifndef _FORM_MAIN_H_
#include "form_main.h"
#endif

#ifndef  _MISC_WIFI_H_
#include "misc_wifi.h"
#endif



#ifndef  _MT5911_COMMON_H_
#include "mt5911_common.h"
#endif

#ifndef  _MAN_FDM_H_
#include "man_fdm.h"
#endif

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmWiFiALC2400M *frmWiFiALC2400M;
//===========================================================================
static void CNF_ReadAlc2400MFromNVRAM(void)
{
    frmWiFiALC2400M->UploadAlc2400MFromFlashDone();
}

//---------------------------------------------------------------------------
static void CNF_WriteAlc2400MToNVRAM(void)
{
    frmWiFiALC2400M->DownloadAlc2400MToFlashDone();
}

//---------------------------------------------------------------------------
static void CNF_ReadAlcCCKFromEE(void)
{
    frmWiFiALC2400M->CNF_ReadAlcCCKFromEE();
}

//---------------------------------------------------------------------------
static void CNF_ReadAlcOFDMFromEE(void)
{
    frmWiFiALC2400M->CNF_ReadAlcOFDMFromEE();
}

//---------------------------------------------------------------------------
static void CNF_ReadAlcSlopeFromEE(void)
{
    frmWiFiALC2400M->CNF_ReadAlcSlopeFromEE();
}
//===========================================================================
__fastcall TfrmWiFiALC2400M::TfrmWiFiALC2400M(TComponent* Owner)
        : TForm(Owner)
{
    m_edtTxAlcCCK[ 0] = m_edtTxAlcCCK00;
    m_edtTxAlcCCK[ 1] = m_edtTxAlcCCK01;
    m_edtTxAlcCCK[ 2] = m_edtTxAlcCCK02;
    m_edtTxAlcCCK[ 3] = m_edtTxAlcCCK03;
    m_edtTxAlcCCK[ 4] = m_edtTxAlcCCK04;
    m_edtTxAlcCCK[ 5] = m_edtTxAlcCCK05;
    m_edtTxAlcCCK[ 6] = m_edtTxAlcCCK06;
    m_edtTxAlcCCK[ 7] = m_edtTxAlcCCK07;
    m_edtTxAlcCCK[ 8] = m_edtTxAlcCCK08;
    m_edtTxAlcCCK[ 9] = m_edtTxAlcCCK09;
    m_edtTxAlcCCK[10] = m_edtTxAlcCCK10;
    m_edtTxAlcCCK[11] = m_edtTxAlcCCK11;
    m_edtTxAlcCCK[12] = m_edtTxAlcCCK12;
    m_edtTxAlcCCK[13] = m_edtTxAlcCCK13;

    m_edtTxOutputPowerDbCCK[ 0] = m_edtTxOutputPowerDbCCK00;
    m_edtTxOutputPowerDbCCK[ 1] = m_edtTxOutputPowerDbCCK01;
    m_edtTxOutputPowerDbCCK[ 2] = m_edtTxOutputPowerDbCCK02;
    m_edtTxOutputPowerDbCCK[ 3] = m_edtTxOutputPowerDbCCK03;
    m_edtTxOutputPowerDbCCK[ 4] = m_edtTxOutputPowerDbCCK04;
    m_edtTxOutputPowerDbCCK[ 5] = m_edtTxOutputPowerDbCCK05;
    m_edtTxOutputPowerDbCCK[ 6] = m_edtTxOutputPowerDbCCK06;
    m_edtTxOutputPowerDbCCK[ 7] = m_edtTxOutputPowerDbCCK07;
    m_edtTxOutputPowerDbCCK[ 8] = m_edtTxOutputPowerDbCCK08;
    m_edtTxOutputPowerDbCCK[ 9] = m_edtTxOutputPowerDbCCK09;
    m_edtTxOutputPowerDbCCK[10] = m_edtTxOutputPowerDbCCK10;
    m_edtTxOutputPowerDbCCK[11] = m_edtTxOutputPowerDbCCK11;
    m_edtTxOutputPowerDbCCK[12] = m_edtTxOutputPowerDbCCK12;
    m_edtTxOutputPowerDbCCK[13] = m_edtTxOutputPowerDbCCK13;

    m_btnOFDMTxRate[0] = m_btnOFDMTxRate0;
    m_btnOFDMTxRate[1] = m_btnOFDMTxRate1;
    m_btnOFDMTxRate[2] = m_btnOFDMTxRate2;
    m_btnOFDMTxRate[3] = m_btnOFDMTxRate3;
    m_btnOFDMTxRate[4] = m_btnOFDMTxRate4;
    m_btnOFDMTxRate[5] = m_btnOFDMTxRate5;
    m_btnOFDMTxRate[6] = m_btnOFDMTxRate6;
    m_btnOFDMTxRate[7] = m_btnOFDMTxRate7;

    m_edtOFDMTxAlcOffset[0] = m_edtOFDMTxAlcOffset0;
    m_edtOFDMTxAlcOffset[1] = m_edtOFDMTxAlcOffset1;
    m_edtOFDMTxAlcOffset[2] = m_edtOFDMTxAlcOffset2;
    m_edtOFDMTxAlcOffset[3] = m_edtOFDMTxAlcOffset3;
    m_edtOFDMTxAlcOffset[4] = m_edtOFDMTxAlcOffset4;
    m_edtOFDMTxAlcOffset[5] = m_edtOFDMTxAlcOffset5;
    m_edtOFDMTxAlcOffset[6] = m_edtOFDMTxAlcOffset6;
    m_edtOFDMTxAlcOffset[7] = m_edtOFDMTxAlcOffset7;

    m_edtOFDMTxOutputPowerOffset[0] = m_edtOFDMTxOutputPowerOffset0;
    m_edtOFDMTxOutputPowerOffset[1] = m_edtOFDMTxOutputPowerOffset1;
    m_edtOFDMTxOutputPowerOffset[2] = m_edtOFDMTxOutputPowerOffset2;
    m_edtOFDMTxOutputPowerOffset[3] = m_edtOFDMTxOutputPowerOffset3;
    m_edtOFDMTxOutputPowerOffset[4] = m_edtOFDMTxOutputPowerOffset4;
    m_edtOFDMTxOutputPowerOffset[5] = m_edtOFDMTxOutputPowerOffset5;
    m_edtOFDMTxOutputPowerOffset[6] = m_edtOFDMTxOutputPowerOffset6;
    m_edtOFDMTxOutputPowerOffset[7] = m_edtOFDMTxOutputPowerOffset7;

    m_edtTxAlcOFDM[ 0] = m_edtTxAlcOFDM00;
    m_edtTxAlcOFDM[ 1] = m_edtTxAlcOFDM01;
    m_edtTxAlcOFDM[ 2] = m_edtTxAlcOFDM02;
    m_edtTxAlcOFDM[ 3] = m_edtTxAlcOFDM03;
    m_edtTxAlcOFDM[ 4] = m_edtTxAlcOFDM04;
    m_edtTxAlcOFDM[ 5] = m_edtTxAlcOFDM05;
    m_edtTxAlcOFDM[ 6] = m_edtTxAlcOFDM06;
    m_edtTxAlcOFDM[ 7] = m_edtTxAlcOFDM07;
    m_edtTxAlcOFDM[ 8] = m_edtTxAlcOFDM08;
    m_edtTxAlcOFDM[ 9] = m_edtTxAlcOFDM09;
    m_edtTxAlcOFDM[10] = m_edtTxAlcOFDM10;
    m_edtTxAlcOFDM[11] = m_edtTxAlcOFDM11;
    m_edtTxAlcOFDM[12] = m_edtTxAlcOFDM12;
    m_edtTxAlcOFDM[13] = m_edtTxAlcOFDM13;

    m_edtTxOutputPowerDbOFDM[ 0] = m_edtTxOutputPowerDbOFDM00;
    m_edtTxOutputPowerDbOFDM[ 1] = m_edtTxOutputPowerDbOFDM01;
    m_edtTxOutputPowerDbOFDM[ 2] = m_edtTxOutputPowerDbOFDM02;
    m_edtTxOutputPowerDbOFDM[ 3] = m_edtTxOutputPowerDbOFDM03;
    m_edtTxOutputPowerDbOFDM[ 4] = m_edtTxOutputPowerDbOFDM04;
    m_edtTxOutputPowerDbOFDM[ 5] = m_edtTxOutputPowerDbOFDM05;
    m_edtTxOutputPowerDbOFDM[ 6] = m_edtTxOutputPowerDbOFDM06;
    m_edtTxOutputPowerDbOFDM[ 7] = m_edtTxOutputPowerDbOFDM07;
    m_edtTxOutputPowerDbOFDM[ 8] = m_edtTxOutputPowerDbOFDM08;
    m_edtTxOutputPowerDbOFDM[ 9] = m_edtTxOutputPowerDbOFDM09;
    m_edtTxOutputPowerDbOFDM[10] = m_edtTxOutputPowerDbOFDM10;
    m_edtTxOutputPowerDbOFDM[11] = m_edtTxOutputPowerDbOFDM11;
    m_edtTxOutputPowerDbOFDM[12] = m_edtTxOutputPowerDbOFDM12;
    m_edtTxOutputPowerDbOFDM[13] = m_edtTxOutputPowerDbOFDM13;

}

//------------------------------------------------------------------------------
void TfrmWiFiALC2400M::ReDrawFields(E_DRAW_MASK_WIFI_ALC2400M mask)
{
    if (mask & DRAW_MASK_WIFI_ALC2400M_CCK_ALC)
    {
        for (int i=0; i<WIFI_ALC_2400M_CH_NUM; i++)
        {
            m_edtTxAlcCCK[i]->Text           = IntToStr(m_sWiFiAlcPower2400M.txAlcCCK[i]);
        }
    }

    if (mask & DRAW_MASK_WIFI_ALC2400M_CCK_POWER)
    {
        for (int i=0; i<WIFI_ALC_2400M_CH_NUM; i++)
        {
            m_edtTxOutputPowerDbCCK[i]->Text = IntToStr(m_sWiFiAlcPower2400M.txOutputPowerDBCCK[i]);
        }
    }

    if (mask & DRAW_MASK_WIFI_ALC2400M_OFDM_OFFSET)
    {
        for (int i=0; i<WIFI_ALC_2400M_TX_RATE_NUM; i++)
        {
            m_edtOFDMTxAlcOffset[i]->Text         = IntToStr(m_cOFDMTxAlcOffset[i]);
            m_edtOFDMTxOutputPowerOffset[i]->Text = IntToStr(m_cOFDMTxOutputPowerOffset[i]);
        }
    }

    if (mask & DRAW_MASK_WIFI_ALC2400M_OFDM_ALC)
    {
        for (int i=0; i<WIFI_ALC_2400M_CH_NUM; i++)
        {
            m_edtTxAlcOFDM[i]->Text = IntToStr(m_sWiFiAlcPower2400M.txAlcOFDM[m_pnlOFDMTxRate->Tag][i]);
        }
    }

    if (mask & DRAW_MASK_WIFI_ALC2400M_OFDM_POWER)
    {
        for (int i=0; i<WIFI_ALC_2400M_CH_NUM; i++)
        {
            m_edtTxOutputPowerDbOFDM[i]->Text = IntToStr(m_sWiFiAlcPower2400M.txOutputPowerDBOFDM[m_pnlOFDMTxRate->Tag][i]);
        }
    }

    if (mask & DRAW_MASK_WIFI_ALC2400M_SLOPE)
    {
        m_edtALCSlop1Divider->Text  = IntToStr(m_sWiFiAlcSlope2400M.alcSlop1Divider);
        m_edtALCSlop1Dividend->Text = IntToStr(m_sWiFiAlcSlope2400M.alcSlop1Dividend);
        m_edtALCSlop2Divider->Text  = IntToStr(m_sWiFiAlcSlope2400M.alcSlop2Divider);
        m_edtALCSlop2Dividend->Text = IntToStr(m_sWiFiAlcSlope2400M.alcSlop2Dividend);
    }
}

//---------------------------------------------------------------------------
bool TfrmWiFiALC2400M::CheckFields(E_CHECK_MASK_WIFI_ALC2400M mask)
{
    unsigned char ucdata;

    AnsiString  text;

    if (mask & CHECK_MASK_WIFI_ALC2400M_CCK_ALC)
    {
        for (int i=0; i<NUM_TX_POWER_2400M_CH; i++)
        {
            text = m_edtTxAlcCCK[i]->Text;
            if (!IsValidWiFiTxAlcCCK(text, ucdata))
            {
                edtTxAlcCCKCheck(m_edtTxAlcCCK[i]);
                return false;
            }
            m_sWiFiAlcPower2400M.txAlcCCK[i] = ucdata;
        }
    }

    if (mask & CHECK_MASK_WIFI_ALC2400M_CCK_POWER)
    {
        for (int i=0; i<NUM_TX_POWER_2400M_CH; i++)
        {
            text = m_edtTxOutputPowerDbCCK[i]->Text;
            if (!IsValidWiFiTxOutputPowerDbCCK(text, ucdata))
            {
                edtTxOutputPowerDbCCKCheck(m_edtTxOutputPowerDbCCK[i]);
                return false;
            }
            m_sWiFiAlcPower2400M.txOutputPowerDBCCK[i] = ucdata;
        }
    }

    if (mask & CHECK_MASK_WIFI_ALC2400M_OFDM_ALC)
    {
        for (int i=0; i<NUM_TX_POWER_2400M_CH; i++)
        {
            text = m_edtTxAlcOFDM[i]->Text;
            if (!IsValidWiFiTxOutputPowerDbCCK(text, ucdata))
            {
                edtTxAlcOFDMCheck(m_edtTxAlcOFDM[i]);
                return false;
            }
            m_sWiFiAlcPower2400M.txAlcOFDM[m_pnlOFDMTxRate->Tag][i] = ucdata;
        }
    }

    if (mask & CHECK_MASK_WIFI_ALC2400M_OFDM_POWER)
    {
        for (int i=0; i<NUM_TX_POWER_2400M_CH; i++)
        {
            text = m_edtTxOutputPowerDbOFDM[i]->Text;
            if (!IsValidWiFiTxOutputPowerDbOFDM(text, ucdata))
            {
                edtTxOutputPowerDbOFDMCheck(m_edtTxOutputPowerDbOFDM[i]);
                return false;
            }
            m_sWiFiAlcPower2400M.txOutputPowerDBOFDM[m_pnlOFDMTxRate->Tag][i] = ucdata;
        }
    }

    if (mask & CHECK_MASK_WIFI_ALC2400M_SLOPE)
    {
        // alcSlop1Divider
        text = m_edtALCSlop1Divider->Text;
        if (!IsValidWiFiAlcSlopeDivider(text, ucdata))
        {
            m_edtALCSlopDividerCheck(m_edtALCSlop1Divider);
            return false;
        }
        m_sWiFiAlcSlope2400M.alcSlop1Divider = ucdata;

        // alcSlop1Dividend
        text = m_edtALCSlop1Dividend->Text;
        if (!IsValidWiFiAlcSlopeDividend(text, ucdata))
        {
            m_edtALCSlopDividerCheck(m_edtALCSlop1Dividend);
            return false;
        }
        m_sWiFiAlcSlope2400M.alcSlop1Dividend = ucdata;

        // alcSlop2Divider
        text = m_edtALCSlop2Divider->Text;
        if (!IsValidWiFiAlcSlopeDivider(text, ucdata))
        {
            m_edtALCSlopDividerCheck(m_edtALCSlop2Divider);
            return false;
        }
        m_sWiFiAlcSlope2400M.alcSlop2Divider = ucdata;

        // alcSlop2Dividend
        text = m_edtALCSlop2Dividend->Text;
        if (!IsValidWiFiAlcSlopeDividend(text, ucdata))
        {
            m_edtALCSlopDividerCheck(m_edtALCSlop2Dividend);
            return false;
        }
        m_sWiFiAlcSlope2400M.alcSlop2Dividend = ucdata;
    }

    return true;
}

//---------------------------------------------------------------------------
void TfrmWiFiALC2400M::CurrentPageReset(void)
{
    btnUploadFromFlash->Enabled = true;
    btnDownloadToFlash->Enabled = true;
    btnChangeDB->Enabled = true;
}

//---------------------------------------------------------------------------
void TfrmWiFiALC2400M::CurrentPageLock(void)
{
    btnUploadFromFlash->Enabled = false;
    btnDownloadToFlash->Enabled = false;
    btnChangeDB->Enabled = false;
}

//--------------------------------------------------------------------------
void TfrmWiFiALC2400M::ShowHintLabel(TControl *sender, char* hint)
{
   TPoint pt0 = this->ClientOrigin;
   TPoint pt1 = sender->ClientOrigin;
   lblHint->Left = (pt1.x-pt0.x);
   lblHint->Top  = (pt1.y-pt0.y)+sender->Height+3;