CableTestBench/Sources/CableTestBench.cpp

#include "CableTestBench.h"
#include <QDateTime>
#include "CableTestBenchDefs.h"
#include <QFileInfo>
#include <QProcess>
#include "TestBenchVersion.h"
#include <QMessageBox>

CCableTestBench::CCableTestBench(QObject *parent) :
    QObject(parent),
    mActualCable(CConnectorDefs::UNKNOWN_CONNECTOR_TYPE,&mIOInterface)
{
    w = new MainWindow(0,this);
    w->setWindowTitle(QString("Cablotron %1").arg(TEST_BENCH_VERSION));
}

CCableTestBench::~CCableTestBench()
{
    delete w;
    //mIOInterface.CloseIOModules();
}

int CCableTestBench::Start()
{
   // w->showMaximized();
    w->show();

    mMainPageHandle = w->mMainPage;
    mVisualInspPageHandle = w->mVisualInspPage;
    mCableTestPageHandle = w->mCableTestPage;
    mOptionsPageHandle = w->mOptionsPage;

    if(mTestBenchOptions.LoadSettingFromFile() == RET_OK)
    {
        mOptionsPageHandle->SetCurrentOptions(&mTestBenchOptions);
    }
    {
        mOptionsPageHandle->GetCurrentOptions(&mTestBenchOptions);
    }

    mCableTestEngine.InitCableTestEngine(this,&mTestBenchOptions);

    if(mIOInterface.OpenIOModules(mTestBenchOptions.mIOModuleIPAddress) == RET_ERROR)
    {
        mCableTestReport.AddLogEntry("Impossible de communiquer avec le module d'I/O.\nVérifier la connexion ou l'adresse IP.");
        QMessageBox::critical(0,"Erreur de connexion","Impossible de communiquer avec le module d'I/O.\nVérifier la connexion ou l'adresse IP.");
    }

    mCableTestPageHandle->mGuiRefreshTimer.start();
    connect(&mCableTestReport,SIGNAL(NewTestLogEntry(QString)),mCableTestPageHandle,SLOT(AddTestLogEntry(QString)));




    return 1;
}

CCable * CCableTestBench::GetActualCable()
{
    return &mActualCable;
}

CTestReport *CCableTestBench::GetTestReportHandle()
{
    return &mCableTestReport;
}

quint8 CCableTestBench::DecToBCDByte(const quint8 byte)
{
    quint8 out = 0;

    out = ((byte/10) << 4) + (byte%10);


    return out;

}

quint16 CCableTestBench::DecToBCDWord(const quint16 word)
{
    quint16 out = 0;
    quint16 temp = 0;

    out = word % 10;
    temp = (((word /10) % 10) << 4);
    out += temp;
    temp = (((word / 100) % 10) << 8);
    out += temp;
    temp = (((word / 1000) % 10) << 12);
    out += temp;

    return out;

}

int CCableTestBench::ExecVisualInspectionRequest()
{
    qDebug("Exec Visual Inspection clicked");

   // mCableTestPageHandle->SetVisualInspectionDone(true);
    w->ShowInspectVisuellePage();
    return RET_OK;
}

CCable* CCableTestBench::SetSelectedConnector(CConnectorDefs::eConnectorType ConType)
{
    if(mActualCable.DefineCableByInputConnector(ConType) == RET_ERROR)
    {
        return 0;
    }

    CheckIfReadyForTesting();

    return &mActualCable;
}

int CCableTestBench::VisualInspectionQuitRequest()
{
    mVisualInspPageHandle->FillVisualInspectionResultReport(mCableTestReport.GetInspectionResult());
    if(mCableTestReport.GetInspectionResult()->IsVisualInspectionResultComplete() == true)
    {
        mCableTestPageHandle->SetVisualInspectionDone(true);
    }
    else
    {
        mCableTestPageHandle->SetVisualInspectionDone(false);
    }

    w->ShowCableTestPage();

    CheckIfReadyForTesting();

    return RET_OK;
}

int CCableTestBench::StartPauseAutomaticTestRequest()
{
    if(mCableTestEngine.GetTestEngineCurrentMode() == CCableTestEngine::CABLE_TEST_STBY_MODE)
    {
        mCableTestPageHandle->FillReportCableParametersData(mCableTestReport.GetReportCableParameters());
        mCableTestReport.GetReportCableParameters()->SetCableType(CConnectorDefs::GetConnectorDescription(mActualCable.GetInputConnector()->GetConnectorType()),
                                                                  CConnectorDefs::GetConnectorDescription(mActualCable.GetOutputConnector()->GetConnectorType()));
        mCableTestReport.GetAutomatedTestReport()->SetPinCount(mActualCable.GetOutputConnector()->GetPinCount());

        mCableTestEngine.StartAutomatedTest();
        return RET_OK;
    }
    if(mCableTestEngine.GetTestEngineCurrentMode() == CCableTestEngine::CABLE_AUTO_TEST_RUNNING_MODE)
    {
        mCableTestEngine.PauseAutomatedTest();
        return RET_OK;
    }
    if(mCableTestEngine.GetTestEngineCurrentMode() == CCableTestEngine::CABLE_AUTO_TEST_PAUSED_MODE)
    {
        mCableTestEngine.ResumeAutomatedTest();
        return RET_OK;
    }
    else    //Button shouldn't be used in manual mode...
    {
        return RET_ERROR;
    }

    return RET_OK;
}

int CCableTestBench::StartStopManualTestRequest()
{
    if(mCableTestEngine.GetTestEngineCurrentMode() == CCableTestEngine::CABLE_TEST_STBY_MODE)
    {
        mCableTestEngine.StartManualTest();
        return RET_OK;
    }
    if(mCableTestEngine.GetTestEngineCurrentMode() == CCableTestEngine::CABLE_TEST_MANUAL_MODE)
    {
        mCableTestEngine.StopManualTest();
        return RET_OK;
    }
    else    //Button shouldn't be used in Automatic mode...
    {
        return RET_ERROR;
    }


}

int CCableTestBench::NewCableRequest()
{
    mActualCable.DefineCableByInputConnector(CConnectorDefs::UNKNOWN_CONNECTOR_TYPE);
    mVisualInspPageHandle->ResetForm();
    mCableTestPageHandle->ResetCable();
    mCableTestPageHandle->DisableStartTestBtn();
    mCableTestReport.CreateNewTestReport();

    return RET_OK;
}

int CCableTestBench::CheckIfReadyForTesting()
{
    bool VisualInspectionDone = false, ConnectorSelected = false, CableConfigured = false;

    mVisualInspPageHandle->FillVisualInspectionResultReport(mCableTestReport.GetInspectionResult());
    if(mCableTestReport.GetInspectionResult()->IsVisualInspectionResultComplete() == true)
    {
        VisualInspectionDone = true;
    }
    if(mTestBenchOptions.mIgnoreVisualInspection)
    {
        VisualInspectionDone = true;
    }


    if(mCableTestPageHandle->IsCableConfigured())
    {
        CableConfigured = true;
        mCableTestPageHandle->SetCableConfigureStep(true);
    }
    else
    {
        mCableTestPageHandle->SetCableConfigureStep(false);
    }

    ConnectorSelected = mActualCable.IsCableDefined();
    if(ConnectorSelected)
    {
        mCableTestPageHandle->SetConnectorSelStep();
    }
    else
    {
        mCableTestPageHandle->SetConnectorSelStep(false);
    }

    if(VisualInspectionDone && ConnectorSelected && CableConfigured)
    {
        mCableTestPageHandle->EnableStartTestBtn();
    }
    else
    {
        mCableTestPageHandle->DisableStartTestBtn();
    }

    return RET_OK;
}

int CCableTestBench::CableEngineModeChanged(CCableTestEngine::eCableTestEngineMode Mode)
{
    switch(Mode)
    {
        case CCableTestEngine::CABLE_TEST_STBY_MODE:
        {
            mCableTestPageHandle->CableTestEnded();
            if(mCableTestReport.IsAutoTestReportReady())
            {
                SaveReportRequest();
                mCableTestPageHandle->EnableOpenReportBtn();
                if(mCableTestReport.GetGlobalAutoTestResult() == true)
                {
                    mCableTestPageHandle->SetAutoTestResult("Succès!",Qt::darkGreen);
                }
                else
                {
                    mCableTestPageHandle->SetAutoTestResult("Échec",Qt::red);
                }
            }
            break;
        }
        case CCableTestEngine::CABLE_AUTO_TEST_RUNNING_MODE:
        {
            mCableTestPageHandle->CableAutomaticTestStarted();
            break;
        }
        case CCableTestEngine::CABLE_AUTO_TEST_PAUSED_MODE:
        {
            mCableTestPageHandle->CableAutomaticTestPaused();
            break;
        }
        case CCableTestEngine::CABLE_TEST_MANUAL_MODE:
        {
            mCableTestPageHandle->CableManualTestStarted();
            break;
        }
    }

    return RET_OK;
}

int CCableTestBench::ResetAutomaticTestRequest()
{
   return mCableTestEngine.StopAutomatedTest();

}

int CCableTestBench::ManualPinToggleRequest(int ConnectorPinNbr)
{
    return mCableTestEngine.ManualPinToggle(ConnectorPinNbr);
}

int CCableTestBench::RefreshConnectorsStateRequest()
{
    mCableTestPageHandle->SetInputConnectorState(mActualCable.GetInputConnector()->GetInputPinsStates());
    mCableTestPageHandle->SetOutputConnectorState(mActualCable.GetOutputConnector()->GetOutputPinsStates());
    return RET_OK;
}

int CCableTestBench::SaveReportRequest()
{
    return mCableTestReport.SaveReportToFile(&mTestBenchOptions);
}

int CCableTestBench::OpenReportRequest()
{
    QString ReportFile = mCableTestReport.GetLastReportFileName();
    if(ReportFile.isEmpty())
    {
        return RET_ERROR;
    }

    QFileInfo FileInfo(ReportFile);
    QString Command =FileInfo.absoluteFilePath();
    Command.prepend("notepad.exe ");


    QProcess *process = new QProcess;
    process->start(Command);

    return RET_OK;
}

int CCableTestBench::CableConfigChanged()
{
    CheckIfReadyForTesting();
    return RET_OK;
}

int CCableTestBench::TestBenchOptionsChanged()
{
    mOptionsPageHandle->GetCurrentOptions(&mTestBenchOptions);
    mTestBenchOptions.SaveSettingsToFile();



    return RET_OK;
}