UpLowLimp/ZBD_IIIDL_S_Project/Src/TrainManager/fessetting.cpp

#include "fessetting.h"
#include "ui_fessetting.h"
#include "festotalparamdialog.h"
#include "channeldialog.h"
#include "channelonlydialog.h"
//#include "mainwindowpagecontrol.h"
//#include "icemodule.h"
#include <QDebug>
#include <QTimer>
#include "languagemanager.h"
#include "fescontroldialog.h"


FesSetting::FesSetting(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::FesSetting),
    m_FesTotalParamDialog(nullptr),
    m_ChannelDialog(nullptr),
    m_recipeXmlControl(nullptr),
    isRunning(false),
    m_fesTrainTimer(NULL)
{
    ui->setupUi(this);


    for(int i  = 0;i < 30;i++)
        FESABoxList<<true;

    for(int i=0; i<=8; i++)
    {
        isCheckedMuscle[i] = 0;
        isChannelConnected[i] = 1; //默认每个是通道打开的
    }

    //默认显示A电刺激盒
    ui->stackedWidget->setCurrentIndex(0);

    m_FesTotalParamDialog = new FesTotalParamDialog();
    m_ChannelDialog = new ChannelDialog();
    m_ChannelOnlyDialog = new ChannelOnlyDialog();
    m_recipeXmlControl = new RecipeXmlControl();
    initWidget();

    m_fesTrainTimer = new QTimer();
    batteryTimer = new QTimer();


    m_fesTrainTimer->setInterval(60000);
    batteryTimer->setInterval(5000); //5s查询电量
    batteryTimer->start();

    connect(m_fesTrainTimer,&QTimer::timeout,this,&FesSetting::slotTrainTimer);
    connect(batteryTimer,&QTimer::timeout,this,&FesSetting::slotGetBattery);
    connect(FesControlDialog::getInstance(),SIGNAL(signalGetBattery(int,int)),this,SLOT(slotBatteryChanged(int,int)));

    connect(FesControlDialog::getInstance(),SIGNAL(signalDeviceStateChanged(QList<uint8_t>)),this,SLOT(slotDeviceStateChanged(QList<uint8_t>)));
}

FesSetting::~FesSetting()
{
    if(m_FesTotalParamDialog)
        delete m_FesTotalParamDialog;
    if(m_ChannelDialog)
        delete m_ChannelDialog;
    if(m_recipeXmlControl)
        delete m_recipeXmlControl;
    if(batteryTimer)
        delete batteryTimer;
    if(m_ChannelOnlyDialog)
        delete m_ChannelOnlyDialog;
    delete ui;
}

void FesSetting::switchPage(E_FES_PAGE page)
{
    E_fesType = page;
    switch(page)
    {
        case ONLY_FES_E:
        {
            ui->trainTime_Widget->setVisible(true);
            ui->upTime_Widget->setVisible(true);
            ui->downTime_Widget->setVisible(true);
            ui->openTime_Widget->setVisible(true);
            ui->closeTime_Widget->setVisible(true);
            ui->plus_Widget->setVisible(false);
        }
            break;
        case BICYCLE_FES_E:
        {
            ui->trainTime_Widget->setVisible(false);
            ui->upTime_Widget->setVisible(false);
            ui->downTime_Widget->setVisible(false);
            ui->openTime_Widget->setVisible(false);
            ui->closeTime_Widget->setVisible(false);
            ui->plus_Widget->setVisible(true);
        }
            break;
    }
}


void FesSetting::setChannelState()
{

}

void FesSetting::initWidget()
{
    ui->trainTime_Widget->initButton(tr("治疗时间"),"min");
    ui->frequent_Widget->initButton(tr("全局频率"),"Hz");
    ui->upTime_Widget->initButton(tr("上升时间"),"s");
    ui->downTime_Widget->initButton(tr("下降时间"),"s");
    ui->openTime_Widget->initButton(tr("打开时间"),"s");
    ui->closeTime_Widget->initButton(tr("关闭时间"),"s");
    ui->plus_Widget->initButton(tr("全局脉宽"),"μs");

    /*
    else if (language == English_E)  //初始化英文暂停和结束
    {
        ui->trainTime_Widget->initButton("Treatment Time","min");
        ui->frequent_Widget->initButton("Global Frequency","Hz");
        ui->upTime_Widget->initButton("Rise Time","s");
        ui->downTime_Widget->initButton("Fall Time","s");
        ui->openTime_Widget->initButton("Open Time","s");
        ui->closeTime_Widget->initButton("Close Time","s");
        ui->plus_Widget->initButton("Global pulse duration","μs");

    }*/

    ui->channelA1_Widget->initWidget(tr("A1"),1);
    channelList.append(ui->channelA1_Widget);
    ui->channelA2_Widget->initWidget(tr("A2"),2);
    channelList.append(ui->channelA2_Widget);
    ui->channelA3_Widget->initWidget(tr("B1"),3);
    channelList.append(ui->channelA3_Widget);
    ui->channelA4_Widget->initWidget(tr("B2"),4);
    channelList.append(ui->channelA4_Widget);
    ui->channelA5_Widget->initWidget(tr("C1"),5);
    channelList.append(ui->channelA5_Widget);

    ui->channelA6_Widget->initWidget(tr("C2"),6);
    channelList.append(ui->channelA6_Widget);
    ui->channelA7_Widget->initWidget(tr("D1"),7);
    channelList.append(ui->channelA7_Widget);
    ui->channelA8_Widget->initWidget(tr("D2"),8);
    channelList.append(ui->channelA8_Widget);


    foreach(QWidget *widget,channelList)
    {
        connect(widget,SIGNAL(muscleButtonClicked(int)),this,SLOT(slotChannelWidgetClicked(int)));
        //测试使用2024.9.30
        widget->setEnabled(false);
    }


    connect(ui->trainTime_Widget,SIGNAL(fesButtonClicked()),this,SLOT(slotTrainTimeBtnClicked()));
    connect(ui->frequent_Widget,SIGNAL(fesButtonClicked()),this,SLOT(slotFrequentBtnClicked()));
    connect(ui->upTime_Widget,SIGNAL(fesButtonClicked()),this,SLOT(slotUpTimeBtnClicked()));
    connect(ui->downTime_Widget,SIGNAL(fesButtonClicked()),this,SLOT(slotDownTimeBtnClicked()));
    connect(ui->openTime_Widget,SIGNAL(fesButtonClicked()),this,SLOT(slotOpenTimeBtnClicked()));
    connect(ui->closeTime_Widget,SIGNAL(fesButtonClicked()),this,SLOT(slotCloseTimeBtnClicked()));
    connect(ui->plus_Widget,SIGNAL(fesButtonClicked()),this,SLOT(slotPlusBtnClicked()));

    QButtonGroup *buttonGroup = new QButtonGroup();
    buttonGroup->addButton(ui->FESA_Btn);
    buttonGroup->addButton(ui->FESB_Btn);

    ui->FESA_Btn->setVisible(false);
    ui->FESB_Btn->setVisible(false);
    //    buttonGroup->setExclusive(true);

}

void FesSetting::sendAllChannelParam()
{
    //发送单FES数据，给打开的的电刺激，修改全局变量
    for(int i = 1;i <= 8;++i)
    {
        int channel = i;
        //if(channel > 8)
        //channel-=8;
        MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(i-1));

        if(muscleChannel->isEnabled() == false)
            continue;  //如果该通道是灰色的

        ST_MuscleParam st_muscleParam = muscleChannel->getMuscleParam();

        ST_OnlyFESParam st_onlyFesParam;
        st_onlyFesParam.mode = 2;
        st_onlyFesParam.sampleRate = 1;
        st_onlyFesParam.frequency = st_muscleParam.frequency;
        st_onlyFesParam.pulseWidth = st_muscleParam.plus;
        st_onlyFesParam.waveRise = ui->upTime_Widget->getValue()*1000;
        st_onlyFesParam.waveFall = ui->downTime_Widget->getValue()*1000;
        st_onlyFesParam.keepTime = ui->openTime_Widget->getValue()*1000;
        st_onlyFesParam.sleepTime = ui->closeTime_Widget->getValue()*1000;

        int deviceNo = channel/2 + (channel%2?1:0);
        int devcieChannle =  channel%2 ? 1:2;

        FesControlDialog::getInstance()->setOnlyFesParam(deviceNo,devcieChannle,st_onlyFesParam);
    }
}

void FesSetting::slotChannelWidgetClicked(int id)
{
    int channel = id;
    if(channel > 8)
        channel-=8;
    if(E_fesType == BICYCLE_FES_E) //点击了肌肉，必然会有肌肉
    {
        isCheckedMuscle[id] = 1;

    }
    else if(E_fesType == ONLY_FES_E)
    {

    }
    qDebug()<<"Hello1";

    //qDebug() <<"按钮ID:"<<id;
    foreach(QWidget *widget,channelList)
    {
        MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(widget);

        int muscleId = muscleChannel->getMuscleParam().muscleId;
        qDebug() <<"muscleId:"<<muscleId;
        if(muscleId && E_fesType == BICYCLE_FES_E)//此状态list应从muscleButton中去找，而不应从弹窗中找
            FESABoxList[muscleId-1] = false;  //单独电刺激没有肌肉ID；
    }
    qDebug()<<"Hello2";

    MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(id-1));

    ST_MuscleParam st_muscleParam = muscleChannel->getMuscleParam();
    //设置可调节的参数
    //频率
    int tempValue = ui->frequent_Widget->getValue();
    //脉宽
    tempValue = ui->plus_Widget->getValue();


    int deviceNo = channel/2 + (channel%2?1:0);
    int devcieChannle =  channel%2 ? 1:2;

    if(E_fesType == ONLY_FES_E)
    {
        m_ChannelOnlyDialog->setTitle(channel);
        m_ChannelOnlyDialog->setMuscleState(FESABoxList);
        m_ChannelOnlyDialog->setPlusRange(50,500);
        m_ChannelOnlyDialog->setFrequentRange(10,tempValue);

        m_ChannelOnlyDialog->setFrequentValue(st_muscleParam.frequency);
        m_ChannelOnlyDialog->setPlusValue(st_muscleParam.plus);
        m_ChannelOnlyDialog->setMaxCurrentValue(0);
        m_ChannelOnlyDialog->setMinCurrentValue(0);

        m_ChannelOnlyDialog->setMuscleConnectState(isChannelConnected[id]);
        //m_ChannelOnlyDialog->setMuscleId(st_muscleParam.muscleId);

        //设置调参界面状态（运行期间只可以调节最大电流）
        // m_ChannelDialog->setChannleDialogState(isRunning);

        //显示通道对话框
        m_ChannelOnlyDialog->exec();


        ST_MuscleParam st_OnlyChannelMuscleParam = m_ChannelOnlyDialog->getValue();

        muscleChannel->setMuscleParamButton(st_OnlyChannelMuscleParam);
        muscleChannel->setMuscleEnabled(st_OnlyChannelMuscleParam.connectState);
        muscleChannel->setCheckedFesType(E_fesType); //
        isChannelConnected[id] = st_OnlyChannelMuscleParam.connectState; //保存肌肉通道连接状态

        //单独电刺激参数
        ST_OnlyFESParam st_onlyFesParam;
        st_onlyFesParam.mode = 2;
        st_onlyFesParam.sampleRate = 1;
        st_onlyFesParam.waveStyle = 1;
        st_onlyFesParam.frequency = st_OnlyChannelMuscleParam.frequency;
        st_onlyFesParam.pulseWidth = st_OnlyChannelMuscleParam.plus;
        st_onlyFesParam.waveRise = ui->upTime_Widget->getValue()*1000;
        st_onlyFesParam.waveFall = ui->downTime_Widget->getValue()*1000;
        st_onlyFesParam.keepTime = ui->openTime_Widget->getValue()*1000;
        st_onlyFesParam.sleepTime = ui->closeTime_Widget->getValue()*1000;

        if(st_OnlyChannelMuscleParam.connectState)
            FesControlDialog::getInstance()->setOnlyFesParam(deviceNo,devcieChannle,st_onlyFesParam);


    }
    else if(E_fesType == BICYCLE_FES_E)
    {
        m_ChannelDialog->setTitle(channel);
        m_ChannelDialog->setMuscleState(FESABoxList);
        m_ChannelDialog->setFrequentRange(10,tempValue);
        m_ChannelDialog->setPlusRange(50,tempValue);

        //设置参数
        m_ChannelDialog->setFrequentValue(st_muscleParam.frequency);
        m_ChannelDialog->setPlusValue(st_muscleParam.plus);
        m_ChannelDialog->setMaxCurrentValue(0);
        m_ChannelDialog->setMinCurrentValue(0);
        m_ChannelDialog->setMuscleId(st_muscleParam.muscleId);

        //设置调参界面状态（运行期间只可以调节最大电流）
        m_ChannelDialog->setChannleDialogState(isRunning);
        m_ChannelDialog->setMuscleConnectState(isChannelConnected[id]);


        //显示通道对话框
        m_ChannelDialog->exec();

        ST_MuscleParam st_tempMuscleParam = m_ChannelDialog->getValue(); //单独电刺激肌肉名称为空
        st_channelChangedMuscleParams[id] = st_tempMuscleParam;
        //qDebug() <<"i"<<id<<st_tempMuscleParam.minCurrent<<st_tempMuscleParam.maxCurrent;
        isChannelConnected[id] = st_tempMuscleParam.connectState;


        ST_MuscleParam st_MuscleParam = m_ChannelDialog->getValue(); //单独电刺激肌肉名称为空
        muscleChannel->setMuscleParamButton(st_MuscleParam);
        muscleChannel->setCheckedFesType(E_fesType);

        //根据状态设置按钮的状态
        muscleChannel->setMuscleEnabled(st_MuscleParam.connectState);

        //将参数发送给下位机
        ST_FESSetParam st_fesParam;
        st_fesParam.mode = 2;
        st_fesParam.sampleRate = 1;
        st_fesParam.waveStyle = 1;
        st_fesParam.frequency = st_MuscleParam.frequency;
        st_fesParam.pulseWidth = st_MuscleParam.plus;
        st_fesParam.minCurrent = st_MuscleParam.minCurrent;
        st_fesParam.maxCurrent = st_MuscleParam.maxCurrent;



        //设置起止电流
        if(!m_recipeXmlControl->getFESRecipes().isEmpty() && !m_recipeXmlControl->getFESRecipesReverse().isEmpty())
        {
            int muscleId = st_MuscleParam.muscleId;
            if(muscleId > 15)
                muscleId -= 15;
            st_fesParam.startAngle = m_recipeXmlControl->getFESRecipes().at(muscleId-1).startAngle;
            st_fesParam.stopAgnle = m_recipeXmlControl->getFESRecipes().at(muscleId-1).stopAngle;

            st_fesParam.startAngleReverse = m_recipeXmlControl->getFESRecipesReverse().at(muscleId-1).startAngle;
            st_fesParam.stopAgnleReverse = m_recipeXmlControl->getFESRecipesReverse().at(muscleId-1).stopAngle;
            qDebug() <<""<<st_fesParam.startAngle<<" "<<st_fesParam.stopAgnle<<" "<<st_fesParam.startAngleReverse<< " "<<st_fesParam.stopAgnleReverse;
            //判断上下肢
            if(muscleId <= 8)
            {
                qDebug()<<"上肢";
                st_fesParam.upDownLimp = 1;
            }
            else
            {
                qDebug()<<"下肢";
                st_fesParam.upDownLimp = 2;
            }

            //判断左右手
            if(st_MuscleParam.muscleId > 15)
            {
                qDebug()<<"右侧";
                st_fesParam.leftRightLimp = 2;
            }
            else
            {
                qDebug()<<"左侧";
                st_fesParam.leftRightLimp = 1;
            }

        }
        else qDebug() <<"XML为空";
        qDebug() <<"Hello1";

        if(st_MuscleParam.connectState)
        {
            FesControlDialog::getInstance()->setFesParam(deviceNo,devcieChannle,st_fesParam);
            qDebug()<<"11111111111"<<st_fesParam.startAngle<<st_fesParam.stopAgnle;

        }

    }


    //保存参数
    //if(E_fesType == ONLY_FES_E)
  // FesControlDialog::getInstance()->saveOnlyFesParam(st_onlyFesParam);

  //      // else if(E_fesType == BICYCLE_FES_E)
   //     FesControlDialog::getInstance()->saveBicycleFesParam(st_fesParam);

}

//该函数在换成英文后调用两次，不知道啥原因，切换导致出现调用次数增加
void FesSetting::slotTrainTimeBtnClicked()
{
    m_FesTotalParamDialog->setTitleAndUnit(tr("训练时间"),"min");
    m_FesTotalParamDialog->setRange(1,120);

    int oldValue = ui->trainTime_Widget->getValue();
    m_FesTotalParamDialog->setValue(oldValue);
    m_FesTotalParamDialog->show();
    m_FesTotalParamDialog->exec();
    int newValue = m_FesTotalParamDialog->getValue();
    ui->trainTime_Widget->setData(newValue);
}

void FesSetting::slotFrequentBtnClicked()
{
    m_FesTotalParamDialog->setTitleAndUnit(tr("全局频率"),"Hz");
    m_FesTotalParamDialog->setRange(10,100);
    int oldValue = ui->frequent_Widget->getValue();
    m_FesTotalParamDialog->setValue(oldValue);
    m_FesTotalParamDialog->show();
    m_FesTotalParamDialog->exec();
    int newValue = m_FesTotalParamDialog->getValue();
    ui->frequent_Widget->setData(newValue);

    sendAllChannelParam();
}

void FesSetting::slotPlusBtnClicked()
{
    m_FesTotalParamDialog->setTitleAndUnit(tr("全局脉宽"),"μs");
    m_FesTotalParamDialog->setRange(50,500);
    int oldValue = ui->plus_Widget->getValue();
    m_FesTotalParamDialog->setValue(oldValue);
    m_FesTotalParamDialog->show();
    m_FesTotalParamDialog->exec();
    int newValue = m_FesTotalParamDialog->getValue();
    ui->plus_Widget->setData(newValue);

    sendAllChannelParam();

}

void FesSetting::slotUpTimeBtnClicked()
{
    m_FesTotalParamDialog->setRange(0,30);
    m_FesTotalParamDialog->setTitleAndUnit(tr("上升时间"),"s");
    int oldValue = ui->upTime_Widget->getValue();
    m_FesTotalParamDialog->setValue(oldValue);
    m_FesTotalParamDialog->show();
    m_FesTotalParamDialog->exec();
    int newValue = m_FesTotalParamDialog->getValue();
    ui->upTime_Widget->setData(newValue);

    sendAllChannelParam();
   // if(st_MuscleParam.connectState)
        //FesControlDialog::getInstance()->setPreCurrentState(m_deviceNo,m_deviceChannel,false);
}

void FesSetting::slotDownTimeBtnClicked()
{
    m_FesTotalParamDialog->setRange(0,30);
    m_FesTotalParamDialog->setTitleAndUnit(tr("下降时间"),"s");
    int oldValue = ui->downTime_Widget->getValue();
    m_FesTotalParamDialog->setValue(oldValue);
    m_FesTotalParamDialog->show();
    m_FesTotalParamDialog->exec();
    int newValue = m_FesTotalParamDialog->getValue();
    ui->downTime_Widget->setData(newValue);

    sendAllChannelParam();
}

void FesSetting::slotOpenTimeBtnClicked()
{
    m_FesTotalParamDialog->setTitleAndUnit(tr("打开时间"),"s");
    int oldValue = ui->openTime_Widget->getValue();
    m_FesTotalParamDialog->setValue(oldValue);
    m_FesTotalParamDialog->show();
    m_FesTotalParamDialog->exec();
    int newValue = m_FesTotalParamDialog->getValue();
    ui->openTime_Widget->setData(newValue);

    sendAllChannelParam();
}

void FesSetting::slotCloseTimeBtnClicked()
{
    m_FesTotalParamDialog->setTitleAndUnit(tr("关闭时间"),"s");
    int oldValue = ui->closeTime_Widget->getValue();
    m_FesTotalParamDialog->setValue(oldValue);
    m_FesTotalParamDialog->show();
    m_FesTotalParamDialog->exec();
    int newValue = m_FesTotalParamDialog->getValue();
    ui->closeTime_Widget->setData(newValue);

    sendAllChannelParam();
}

void FesSetting::on_FESA_Btn_clicked()
{
    ui->stackedWidget->setCurrentIndex(0);
}

void FesSetting::on_FESB_Btn_clicked()
{
    ui->stackedWidget->setCurrentIndex(1);
}

//从该界面启动游戏
void FesSetting::on_OK_Btn_clicked()
{

    switch (E_fesType) {
    case ONLY_FES_E://单纯电刺激
    {
        if(ui->OK_Btn->text() == tr("开始"))
        {
            m_fesTrainTimer->start();
            ui->trainTime_Widget->setTitle(tr("剩余时间"));
            m_trainTime = ui->trainTime_Widget->getValue();
            isRunning = true;
            ui->OK_Btn->setText(tr("结束"));

            switchFES(true);//打开电刺激
        }
        else if(ui->OK_Btn->text() == tr("结束"))
        {
            switchFES(false);//关闭电刺激
            isRunning = false;
            ui->OK_Btn->setText(tr("开始"));

            m_fesTrainTimer->stop();
            ui->trainTime_Widget->setTitle(tr("治疗时间"));

//            switchFES(false);//打开电刺激

        }
    }
        break;
    case BICYCLE_FES_E: //FES踏车
    {
        //启动游戏
        emit signalStartGame();
    }
        break;
    }
}

void FesSetting::slotTrainTimer()
{
    m_trainTime--;
    ui->trainTime_Widget->setData(m_trainTime);
    //治疗结束
    if(0 == m_trainTime)
    {
        on_OK_Btn_clicked();
    }
}

void FesSetting::slotGetBattery()
{
    for(int i = 1;i <= 4;++i) //4个设备
    {
      if(FesControlDialog::getInstance()->getDeviceStateByNo(i))
        {

            FesControlDialog::getInstance()->queryDeviceState(i);
            // qDebug()<<"查询电量："<<i;
        }
       // else
        //    qDebug()<<"未连接："<<i;

    }
}

void FesSetting::slotBatteryChanged(int deviceNo,int batteryValue)//设备1-4
{


        //MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(2*i));
        if(FesControlDialog::getInstance()->getDeviceStateByNo(deviceNo))
        {

            MuscleButton* muscleChannel1 = dynamic_cast<MuscleButton*>(channelList.at(2*(deviceNo-1)));
            MuscleButton* muscleChannel2 = dynamic_cast<MuscleButton*>(channelList.at(2*(deviceNo-1)+1));

            //int batteryValue1 = FesControlDialog::getInstance()->getBatteryValue(i);
            muscleChannel1->setBLEBattery(batteryValue);
            muscleChannel2->setBLEBattery(batteryValue);

        }


}

void FesSetting::slotDeviceStateChanged(QList<uint8_t> deviceState)
{

    if(deviceState.at(0))
    {
        ui->channelA1_Widget->setEnabled(true);
        ui->channelA2_Widget->setEnabled(true);
    }
    else
    {
        ui->channelA1_Widget->setEnabled(false);
        ui->channelA2_Widget->setEnabled(false);
    }

    for(int i = 0;i < deviceState.size();++i)
    {

        if(deviceState.at(i))
        {
            channelList.at(2*i)->setEnabled(true);
            MuscleButton* muscleChannel1 = dynamic_cast<MuscleButton*>(channelList.at(2*i));
            muscleChannel1->setConnectState(true);
            channelList.at(2*i + 1)->setEnabled(true);
            MuscleButton* muscleChannel2 = dynamic_cast<MuscleButton*>(channelList.at(2*i+1));
            muscleChannel2->setConnectState(true);

            //电量设置
            //int batteryValue1 = FesControlDialog::getInstance()->getBatteryValue(i);
            //muscleChannel1->setBLEBattery(batteryValue1);
            //muscleChannel2->setBLEBattery(batteryValue1);
        }
        else
        {
            channelList.at(2*i)->setEnabled(false);
            MuscleButton* muscleChannel1 = dynamic_cast<MuscleButton*>(channelList.at(2*i));
            muscleChannel1->setConnectState(false);
            channelList.at(2*i + 1)->setEnabled(false);
            MuscleButton* muscleChannel2 = dynamic_cast<MuscleButton*>(channelList.at(2*i+1));
            muscleChannel2->setConnectState(false);

            muscleChannel1->setBLEBattery(0);
            muscleChannel2->setBLEBattery(0);
        }

       // qDebug()<< channelList.at(2*i)->isEnabled()<< channelList.at(2*i)->isEnabled()<<" ";
    }
}

void FesSetting::switchFES(bool on)
{
    for(int i = 0;i < 8;i++)
    {

        MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(i));
        ST_MuscleParam st_muscleParam = muscleChannel->getMuscleParam();

        if(st_muscleParam.connectState)
        {
            int deviceNo = i/2 + 1;
            int devcieChannle =  (i+1)%2 ? 1:2;

            FesControlDialog::getInstance()->switchDeviceChannel(deviceNo,devcieChannle,on);
        }
    }
}

void FesSetting::switchBicycleFES(bool on)
{
    for(int i = 0;i < 8;i++)
    {
        MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(i));
        ST_MuscleParam st_muscleParam = muscleChannel->getMuscleParam();
        if(st_muscleParam.connectState)
        {
            int deviceNo = i/2 + 1;
            int devcieChannle =  (i+1)%2 ? 1:2;
            FesControlDialog::getInstance()->switchDeviceChannel(deviceNo,devcieChannle,on);

        }
    }
}

void FesSetting::changeEvent(QEvent* event)
{
    switch (event->type())
    {
    case QEvent::LanguageChange:
    {
        E_LANGUAGE language = LanguageManager::getInstance()->getCurrentLanguage();

        switch(language)
        {

            case Chinese_E:
            {
                ui->trainTime_Widget->initButton(tr("治疗时间"),"min");
                ui->frequent_Widget->initButton(tr("全局频率"),"Hz");
                ui->upTime_Widget->initButton(tr("上升时间"),"s");
                ui->downTime_Widget->initButton(tr("下降时间"),"s");
                ui->openTime_Widget->initButton(tr("打开时间"),"s");
                ui->closeTime_Widget->initButton(tr("关闭时间"),"s");
                ui->plus_Widget->initButton(tr("全局脉宽"),"μs");

            }; break;
            case English_E:
            {
                ui->trainTime_Widget->initButton(tr("Treatment Time"),"min");
                ui->frequent_Widget->initButton(tr("Global Frequency"),"Hz");
                ui->upTime_Widget->initButton(tr("Rise Time"),"s");
                ui->downTime_Widget->initButton(tr("Fall Time"),"s");
                ui->openTime_Widget->initButton(tr("Open Time"),"s");
                ui->closeTime_Widget->initButton(tr("Close Time"),"s");
                ui->plus_Widget->initButton(tr("Global pulse duration"),"μs");
                qDebug() <<"改变语言"<<language;
            };break;
        }
        ui->retranslateUi(this);

    } break;
    default:
    {
        QWidget::changeEvent(event);

    }
        break;
    }

    //for(int i=1; i<=8; i++)
      //  if(E_fesType == BICYCLE_FES_E && isCheckedMuscle[i] == 1)
        //{
                //qDebug()<<"i:"<<i;
          //      MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(i-1));

                /*ST_MuscleParam tempMuscleParam;
                tempMuscleParam.muscleId = 0;
                tempMuscleParam.muscleName = "";
                tempMuscleParam.maxCurrent = 0;
                tempMuscleParam.minCurrent = 0;
                tempMuscleParam.plus = 200;
                tempMuscleParam.frequency = 10;
                muscleChannel->setMuscleParamButton(tempMuscleParam);

                qDebug() <<"FES车点击为0:"<<i;*/
            //    muscleChannel->setCheckedFesType(BICYCLE_FES_E);
        //}

}

void FesSetting::showEvent(QShowEvent *event)
{
    Q_UNUSED(event)


    ui->trainTime_Widget->setData(20);
    ui->frequent_Widget->setData(100);
    ui->upTime_Widget->setData(2);
    ui->downTime_Widget->setData(2);
    ui->openTime_Widget->setData(10);
    ui->closeTime_Widget->setData(10);
    ui->plus_Widget->setData(200);
    ui->OK_Btn->setText(tr("开始"));

    switch(E_fesType)
    {
        case ONLY_FES_E://
        {
            qDebug() <<"E_fesType:单纯电刺激";
            for(int i=1; i<=8; i++)
                //if(isCheckedMuscle[i] == 1) //按照上一次显示的
                {


                    MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(i-1));

                    ST_MuscleParam tempMuscleParam;
                    tempMuscleParam.muscleId = 0;
                    tempMuscleParam.muscleName = "";
                    tempMuscleParam.maxCurrent = 0;
                    tempMuscleParam.minCurrent = 0;
                    tempMuscleParam.plus = 200;
                    tempMuscleParam.frequency = 10;
                    muscleChannel->setMuscleParamButton(tempMuscleParam);
                    qDebug() <<"窗体i:"<<i;
                    muscleChannel->setCheckedFesType(E_fesType);
                }
        }
        break;
        case BICYCLE_FES_E: //FES踏车
        {
            for(int i=1; i<=8; i++)
                if(isCheckedMuscle[i] == 1)
                {
                     //I==2,I==3;
                    MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(i-1));
                    //if()
                    muscleChannel->setMuscleParamButton(st_channelChangedMuscleParams[i]);
                     qDebug() <<"FES车点击为1:"<<i;
                    muscleChannel->setCheckedFesType(E_fesType);
                    //if(muscleChannel->getMuscleParam().maxCurrent)
                    //ST_MuscleParam st_MuscleParam = m_ChannelDialog->getValue(); //单独电刺激肌肉名称为空
                    //st_channelChangedMuscleParams[id] = st_MuscleParam;
                }
                else if(isCheckedMuscle[i] == 0)
                {
                    //qDebug()<<"i:"<<i;
                    MuscleButton* muscleChannel = dynamic_cast<MuscleButton*>(channelList.at(i-1));

                    ST_MuscleParam tempMuscleParam;
                    tempMuscleParam.muscleId = 0;
                    tempMuscleParam.muscleName = "";
                    tempMuscleParam.maxCurrent = 0;
                    tempMuscleParam.minCurrent = 0;
                    tempMuscleParam.plus = 200;
                    tempMuscleParam.frequency = 10;
                    muscleChannel->setMuscleParamButton(tempMuscleParam);

                    qDebug() <<"FES车点击为0:"<<i;
                    muscleChannel->setCheckedFesType(ONLY_FES_E);
                }
        }
        break;
    }

    //从单独电刺激和游戏电刺激进入，进行初始化，区分显示肌肉和部位

}