#include <gui.h>
Definiert in Zeile 50 der Datei gui.h.
LaufroboterDialog::LaufroboterDialog | ( | QApplication * | _mainApp | ) |
Konstructor
*_mainApp |
Definiert in Zeile 13 der Datei gui_global.cpp.
Benutzt apply_button_clicked(), LaufroboterMainWindow::applyButton, LaufroboterMainWindow::applyButtonVI, dad, DBG, LaufroboterMainWindow::debugLabel, debugMutex, delete_button_clicked(), LaufroboterMainWindow::envLoadFileButton, LaufroboterMainWindow::envSaveFileButton, LaufroboterMainWindow::envSaveMatlabFileButton, LaufroboterMainWindow::envSaveRewardButton, guiMutex, i_update, iMantisse, iteration_button_clicked(), learn_button_clicked(), learn_method_nn_clicked(), learn_method_vi_clicked(), lg, load_button_clicked(), LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, pix, pkt, LaufroboterMainWindow::QTab, resume_simulation_clicked(), SimulationDialogUI::resumeSimulationButton, LaufroboterMainWindow::resumeSimulationButton, save_button_clicked(), save_feedback_clicked(), save_matlab_button_clicked(), sd, simuDialog, simulationWalk(), simuPos, st, start_simulation_clicked(), SimulationDialogUI::startSimulationButton, LaufroboterMainWindow::startSimulationButton, stop_button_clicked(), stop_simulation_clicked(), SimulationDialogUI::stopSimulationButton, LaufroboterMainWindow::stopSimulationButton, LaufroboterMainWindow::strategyTable, tableMutex, v24, v24_accept_button_clicked(), v24_copy_states_and_gamma_to_robot_button_clicked(), v24_debug_button_clicked(), v24_distance_button_clicked(), v24_exploration_accept_clicked(), v24_exploration_mode_changed(), v24_explore_feedback_button_clicked(), v24_get_exploration_clicked(), v24_get_states_and_gamma_from_robot_button_clicked(), v24_getPositionAndMode_button_clicked(), v24_ramtest_button_clicked(), v24_reset_distance_button_clicked(), v24_start_learning_button_clicked(), v24_start_walking_button_clicked(), v24_stop_walking_button_clicked(), LaufroboterMainWindow::v24AcceptButton, LaufroboterMainWindow::v24CopyStatesAndGammaToRobotButton, LaufroboterMainWindow::v24DebugButton, LaufroboterMainWindow::v24ExplorationAcceptButton, LaufroboterMainWindow::v24ExplorationModeEGreedy, LaufroboterMainWindow::v24ExplorationModeValueBased, LaufroboterMainWindow::v24ExploreFeedbackButton, LaufroboterMainWindow::v24GetDistanceButton, LaufroboterMainWindow::v24GetExplorationButton, LaufroboterMainWindow::v24GetPositionAndModeButton, LaufroboterMainWindow::v24GetStatesAndGammaFromRobotButton, LaufroboterMainWindow::v24RamtestButton, LaufroboterMainWindow::v24ResetDistanceButton, LaufroboterMainWindow::v24StartLearningButton, LaufroboterMainWindow::v24StartWalkingButton, LaufroboterMainWindow::v24StopWalkingButton, LaufroboterMainWindow::viDeleteButton, LaufroboterMainWindow::viDeleteButton2, LaufroboterMainWindow::viGammaInput, LaufroboterMainWindow::viIterationButton, LaufroboterMainWindow::viIterationButton2, LaufroboterMainWindow::viLearnWithNN, LaufroboterMainWindow::viLearnWithVI, LaufroboterMainWindow::viLernenButton, LaufroboterMainWindow::viLernenButton2, LaufroboterMainWindow::viSpeedSlider, LaufroboterMainWindow::viStopButton, LaufroboterMainWindow::viStopButton2, LaufroboterMainWindow::ViTab, LaufroboterMainWindow::viValueTable, XMAX und YMAX.
00013 { 00014 00015 dad = _mainApp; 00016 00017 this->lg = new LaufroboterMainWindow (this); 00018 this->sd = new SimulationDialogUI(); 00019 00020 this->lg->viSpeedSlider->setEnabled(false); 00021 this->lg->ViTab->setEnabled(false); 00022 this->lg->QTab->setEnabled(false); 00023 00024 // Default-Werte initialisieren 00025 this->lg->viValueTable->setNumRows(0); 00026 this->lg->viValueTable->setNumCols(0); 00027 this->lg->strategyTable->setNumRows(0); 00028 this->lg->strategyTable->setNumCols(0); 00029 00030 this->lg->viSpeedSlider->setEnabled(false); 00031 this->lg->viGammaInput->setText("0.9"); 00032 this->lg->debugLabel->setEnabled(true); 00033 this->lg->numRows->setMaxValue(YMAX); 00034 this->lg->numCols->setMaxValue(XMAX); 00035 this->lg->viLearnWithNN->setEnabled(false); 00036 this->lg->viLearnWithVI->setEnabled(false); 00037 this->lg->viLearnWithNN->setChecked(false); 00038 this->lg->viLearnWithVI->setChecked(false); 00039 00040 this->pkt = NULL; 00041 00042 this->tableMutex = new QMutex; 00043 this->debugMutex = new QMutex; 00044 this->guiMutex = new QMutex; 00045 this->guiMutex->unlock(); 00046 00047 DBG(); 00048 00049 lg->show(); 00050 this->i_update=0; 00051 this->iMantisse = 0; 00052 00053 // Timer für die Simulation initialisieren 00054 this->st = new QTimer(); 00055 connect(this->st, SIGNAL(timeout()), this, SLOT(simulationWalk())); 00056 this->simuDialog = NULL; 00057 this->simuPos.setX(0); 00058 this->simuPos.setY(0); 00059 00060 connect(lg->applyButton, SIGNAL(clicked()), this, SLOT(apply_button_clicked())); 00061 connect(lg->applyButtonVI, SIGNAL(clicked()), this, SLOT(apply_button_clicked())); 00062 00063 connect(lg->viLernenButton, SIGNAL(clicked()), this, SLOT(learn_button_clicked())); 00064 connect(lg->viDeleteButton, SIGNAL(clicked()), this, SLOT(delete_button_clicked())); 00065 connect(lg->viStopButton, SIGNAL(clicked()), this, SLOT(stop_button_clicked())); 00066 connect(lg->viIterationButton, SIGNAL(clicked()), this, SLOT(iteration_button_clicked())); 00067 connect(lg->viLernenButton2, SIGNAL(clicked()), this, SLOT(learn_button_clicked())); 00068 connect(lg->viDeleteButton2, SIGNAL(clicked()), this, SLOT(delete_button_clicked())); 00069 connect(lg->viStopButton2, SIGNAL(clicked()), this, SLOT(stop_button_clicked())); 00070 connect(lg->viIterationButton2, SIGNAL(clicked()), this, SLOT(iteration_button_clicked())); 00071 00072 00073 connect(lg->envLoadFileButton, SIGNAL(clicked()), this, SLOT(load_button_clicked())); 00074 connect(lg->envSaveFileButton, SIGNAL(clicked()), this, SLOT(save_button_clicked())); 00075 connect(lg->envSaveMatlabFileButton, SIGNAL(clicked()), this, SLOT(save_matlab_button_clicked())); 00076 connect(lg->envSaveRewardButton, SIGNAL(clicked()), this, SLOT(save_feedback_clicked())); 00077 connect(lg->viLearnWithNN, SIGNAL(clicked()), this, SLOT(learn_method_nn_clicked())); 00078 connect(lg->viLearnWithVI, SIGNAL(clicked()), this, SLOT(learn_method_vi_clicked())); 00079 00080 // V24 Test 00081 connect(lg->v24StartWalkingButton, SIGNAL(clicked()), this, SLOT(v24_start_walking_button_clicked())); 00082 connect(lg->v24StopWalkingButton, SIGNAL(clicked()), this, SLOT(v24_stop_walking_button_clicked())); 00083 connect(lg->v24StartLearningButton, SIGNAL(clicked()), this, SLOT(v24_start_learning_button_clicked())); 00084 connect(lg->v24CopyStatesAndGammaToRobotButton, SIGNAL(clicked()), this, SLOT(v24_copy_states_and_gamma_to_robot_button_clicked())); 00085 connect(lg->v24GetStatesAndGammaFromRobotButton, SIGNAL(clicked()), this, SLOT(v24_get_states_and_gamma_from_robot_button_clicked())); 00086 connect(lg->v24GetPositionAndModeButton, SIGNAL(clicked()), this, SLOT(v24_getPositionAndMode_button_clicked())); 00087 connect(lg->v24RamtestButton, SIGNAL(clicked()), this, SLOT(v24_ramtest_button_clicked())); 00088 connect(lg->v24ExploreFeedbackButton, SIGNAL(clicked()), this, SLOT(v24_explore_feedback_button_clicked())); 00089 v24 = new V24Control(this->guiMutex, this); 00090 connect(lg->v24AcceptButton, SIGNAL(clicked()), this, SLOT(v24_accept_button_clicked())); 00091 connect(lg->v24GetDistanceButton, SIGNAL(clicked()), this, SLOT(v24_distance_button_clicked())); 00092 connect(lg->v24ResetDistanceButton, SIGNAL(clicked()), this, SLOT(v24_reset_distance_button_clicked())); 00093 connect(lg->v24ExplorationAcceptButton, SIGNAL(clicked()), this, SLOT(v24_exploration_accept_clicked())); 00094 connect(lg->v24GetExplorationButton, SIGNAL(clicked()), this, SLOT(v24_get_exploration_clicked())); 00095 connect(lg->v24ExplorationModeEGreedy, SIGNAL(clicked()), this, SLOT(v24_exploration_mode_changed())); 00096 connect(lg->v24ExplorationModeValueBased, SIGNAL(clicked()), this, SLOT(v24_exploration_mode_changed())); 00097 connect(lg->v24DebugButton, SIGNAL(clicked()), this, SLOT(v24_debug_button_clicked())); 00098 00099 // Bilder initialisieren 00100 pix[0] = QPixmap ((QString)"pix/0.png"); 00101 pix[1] = QPixmap ((QString)"pix/1.png"); 00102 pix[2] = QPixmap ((QString)"pix/2.png"); 00103 pix[3] = QPixmap ((QString)"pix/3.png"); 00104 pix[4] = QPixmap ((QString)"pix/4.png"); 00105 pix[5] = QPixmap ((QString)"pix/5.png"); 00106 00107 00108 // Simulationsdialog 00109 this->lg->stopSimulationButton->setEnabled(false); 00110 this->lg->startSimulationButton->setEnabled(false); 00111 this->lg->resumeSimulationButton->setEnabled(false); 00112 this->sd->stopSimulationButton->setEnabled(false); 00113 this->sd->startSimulationButton->setEnabled(false); 00114 this->sd->resumeSimulationButton->setEnabled(false); 00115 connect(lg->startSimulationButton, SIGNAL(clicked()), this, SLOT(start_simulation_clicked())); 00116 connect(lg->stopSimulationButton, SIGNAL(clicked()), this, SLOT(stop_simulation_clicked())); 00117 connect(lg->resumeSimulationButton, SIGNAL(clicked()), this, SLOT(resume_simulation_clicked())); 00118 connect(sd->startSimulationButton, SIGNAL(clicked()), this, SLOT(start_simulation_clicked())); 00119 connect(sd->stopSimulationButton, SIGNAL(clicked()), this, SLOT(stop_simulation_clicked())); 00120 connect(sd->resumeSimulationButton, SIGNAL(clicked()), this, SLOT(resume_simulation_clicked())); 00121 00122 00123 }
LaufroboterDialog::~LaufroboterDialog | ( | ) |
Destructor
Definiert in Zeile 6 der Datei gui_global.cpp.
Benutzt pkt.
00006 { 00007 delete (this->pkt); 00008 }
void LaufroboterDialog::adjust_network_error | ( | double | _newError | ) | [private, slot] |
Definiert in Zeile 147 der Datei gui_global.cpp.
Benutzt DBG, lg und LaufroboterMainWindow::netDesiredError.
Wird benutzt von apply_button_clicked().
00147 { 00148 // Debug-Ausgabe 00149 DBG(); 00150 printf ("network error automatically adjusted from %f to: %f\n", this->lg->netDesiredError->text().toDouble(), 00151 _newError); 00152 00153 // Textfeld aktualisieren 00154 this->lg->netDesiredError->setText (QString::number(_newError)); 00155 }
void LaufroboterDialog::apply_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 3 der Datei gui_config.cpp.
Benutzt adjust_network_error(), SimulationDialogUI::canvasView, LaufroboterMainWindow::canvasView, DBG, debugOutput(), LaufroboterMainWindow::envLoadFileButton, LaufroboterMainWindow::envRewardTable, LaufroboterMainWindow::envSaveFileButton, LaufroboterMainWindow::envSaveMatlabFileButton, LaufroboterMainWindow::envSaveRewardButton, feedbackClicked(), gamma, guiReady, i_cell, iMantisse, learn_method_vi_clicked(), lg, LaufroboterMainWindow::mantisseInput, LaufroboterMainWindow::netActivationStepnessHidden, LaufroboterMainWindow::netActivationStepnessOutput, LaufroboterMainWindow::netAutoAdjustError, LaufroboterMainWindow::netDesiredError, LaufroboterMainWindow::netEta, LaufroboterMainWindow::netHiddenActivationFunction, LaufroboterMainWindow::netHiddenLayers, LaufroboterMainWindow::netHiddenUnits, LaufroboterMainWindow::netIterationsBetweenReport, LaufroboterMainWindow::netMaxEpochs, LaufroboterMainWindow::netOutputActivationFunction, LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, pix, pkt, LaufroboterMainWindow::QLearningButton, LaufroboterMainWindow::QTab, scalX, scalY, sd, MyCanvasView::setDimension(), ValueIterationThread::setGamma(), ValueIterationThread::setModusFromExtern(), ValueIterationThread::setNetworkParameters(), ValueIterationThread::setTrainRandomValues(), speed, speed_slider_changed(), LaufroboterMainWindow::startSimulationButton, LaufroboterMainWindow::strategyTable, updatePolicyTable(), vi_train_random_values_changed(), LaufroboterMainWindow::viDeleteButton, LaufroboterMainWindow::viGammaInput, LaufroboterMainWindow::viIterationButton, LaufroboterMainWindow::ViLearningButton, LaufroboterMainWindow::viLernenButton, LaufroboterMainWindow::viRandomValuesSlider, LaufroboterMainWindow::viSpeedSlider, LaufroboterMainWindow::ViTab und LaufroboterMainWindow::viValueTable.
Wird benutzt von LaufroboterDialog() und v24_get_states_and_gamma_from_robot_button_clicked().
00004 { 00005 this->guiReady = false; 00006 static int firstRun=true; 00007 00008 this->lg->ViTab->setEnabled (this->lg->ViLearningButton->isOn()); 00009 this->lg->QTab->setEnabled (this->lg->QLearningButton->isOn()); 00010 00011 00012 static int iHiddenLayers_old = 0, iHiddenUnits_old = 0, iRows_old = 0, iCols_old = 0; 00013 static double dGamma_old = 0; 00014 00015 int iHiddenLayers = 0, iHiddenUnits = 0, iRows = 0, iCols = 0; 00016 double dGamma = 0, dEta = 0; 00017 QTableItem *strategy_item, *value_item, *feedback_item; 00018 00019 // Gamma(Iterationsrate) 00020 this->gamma = dGamma = this->lg->viGammaInput->text().toDouble(); 00021 00022 // Netz Variablen 00023 dEta = this->lg->netEta->text().toDouble(); 00024 iHiddenUnits = this->lg->netHiddenUnits->text().toInt(); 00025 iHiddenLayers = this->lg->netHiddenLayers->text().toInt(); 00026 00027 // Grid Variablen 00028 this->scalY = iRows = lg->numRows->text().toInt(); 00029 this->scalX = iCols = lg->numCols->text().toInt(); 00030 iMantisse = this->lg->mantisseInput->text().toInt(); 00031 i_cell = lg->numRows->text().toInt() * lg->numCols->text().toInt(); 00032 00033 // Anzahl Spalten und Zeilen 00034 lg->viValueTable->setNumRows(iRows); 00035 lg->viValueTable->setNumCols(iCols); 00036 lg->strategyTable->setNumRows(iRows); 00037 lg->strategyTable->setNumCols(iCols); 00038 00039 // Wenn Neuronales Netz angeschaltet, dann 3x3 Feedback aktivieren 00040 lg->envRewardTable->setNumRows(iRows); 00041 lg->envRewardTable->setNumCols(iCols); 00042 00043 // Nur wenn sich bei der Spalten und Zeilenanzahl was geändert hat, wird upgedated 00044 if ((iCols != iCols_old) || (iRows != iRows_old)) 00045 { 00046 // Default-Werte setzen 00047 for (int i=0; i<lg->numRows->text().toInt(); i++) { 00048 for (int j=0; j<lg->numCols->text().toInt(); j++) { 00049 00050 // Neue Items anlegen 00051 value_item = new QTableItem(lg->viValueTable, QTableItem::Never); 00052 strategy_item = new QTableItem(lg->strategyTable, QTableItem::Never); 00053 feedback_item = new QTableItem(lg->envRewardTable, QTableItem::Never); 00054 00055 // Item der Value-Table zuweisen 00056 value_item->setText (QString::number ((double)0.000)); 00057 value_item->setPixmap (pix[5]); 00058 lg->viValueTable->setItem(i, j, value_item); 00059 00060 // Item der Strategy-Table zuweisen 00061 strategy_item->setPixmap (pix[5]); 00062 lg->strategyTable->setItem(i, j, strategy_item); 00063 00064 // Item in der Feedback-Table 00065 feedback_item->setText (""); 00066 lg->envRewardTable->setItem(i, j, feedback_item); 00067 00068 } 00069 } 00070 00071 // Tabelle passend resizen 00072 for (int j=0; j < lg->numCols->text().toInt(); j++) { 00073 lg->viValueTable->adjustColumn(j); 00074 lg->strategyTable->adjustColumn(j); 00075 } 00076 00077 // Thread beenden, wenn schon läuft 00078 if (this->pkt != NULL) { 00079 00080 DBG(); 00081 // Thread sicher beenden 00082 pkt->setModusFromExtern ('q'); 00083 while (pkt->running()); 00084 DBG(); 00085 00086 delete (pkt); 00087 } 00088 00089 // Geschwindigkeit auslesen 00090 speed = this->lg->viSpeedSlider->maxValue()-this->lg->viSpeedSlider->value(); 00091 00092 // Neuen Thread erzeugen 00093 this->pkt = new ValueIterationThread ( 00094 (int)(this->lg->numCols->text().toInt()), 00095 (int)(this->lg->numRows->text().toInt()), 00096 this->gamma, 00097 speed, 00098 this->lg->netHiddenLayers->value(), 00099 this->lg->netHiddenUnits->value()); 00100 00101 this->pkt->setTrainRandomValues((int)((float)this->scalX * (float)this->scalY * 00102 (float)this->lg->viRandomValuesSlider->value() / (float)this->lg->viRandomValuesSlider->maxValue()) 00103 ); 00104 00105 // Verbindung zum KI-Thread um richtig die Tabelle aktualisieren zu lassen 00106 connect( (QObject*)this->pkt, 00107 SIGNAL(emitValue(int, int, double, int)), 00108 (QObject*)this, 00109 SLOT(updatePolicyTable(int, int, double, int)) 00110 ); 00111 connect( (QObject*)this->pkt, 00112 SIGNAL(debugOutput(QString)), 00113 (QObject*)this, 00114 SLOT (debugOutput(QString)) 00115 ); 00116 connect( (QObject*)this->pkt, 00117 SIGNAL(emitNewNetworkError(double)), 00118 (QObject*)this, 00119 SLOT (adjust_network_error(double)) 00120 ); 00121 00122 this->lg->viSpeedSlider->setEnabled (true); 00123 connect(lg->viSpeedSlider, SIGNAL(sliderMoved(int)), this, SLOT(speed_slider_changed(int))); 00124 connect(lg->viRandomValuesSlider, SIGNAL(sliderMoved(int)), this, SLOT(vi_train_random_values_changed(int))); 00125 connect(lg->envRewardTable, SIGNAL(clicked(int, int, int, const QPoint&)), 00126 this, SLOT (feedbackClicked(int, int, int, const QPoint&))); 00127 00128 // Buttons wieder enabeln 00129 this->lg->viLernenButton->setEnabled (true); 00130 this->lg->viIterationButton->setEnabled (true); 00131 this->lg->viSpeedSlider->setEnabled(true); 00132 this->lg->startSimulationButton->setEnabled(true); 00133 this->lg->viDeleteButton->setEnabled(true); 00134 this->lg->envLoadFileButton->setEnabled(true); 00135 this->lg->envSaveFileButton->setEnabled(true); 00136 this->lg->envSaveMatlabFileButton->setEnabled(true); 00137 this->lg->envSaveRewardButton->setEnabled(true); 00138 00139 00140 // Neuronales Netz zunächst deaktivieren 00141 if (firstRun==true) { 00142 this->learn_method_vi_clicked(); 00143 firstRun=false; 00144 } 00145 00146 printf ("Configuration successfully applied\n"); 00147 00148 // In GUI integrierte Simulation 00149 this->lg->canvasView->setDimension ( this->lg->numRows->value(), 00150 this->lg->numCols->value(), 00151 (this->lg->numRows->value()-1)/2, 00152 (this->lg->numCols->value()-1)/2 00153 //this->simuPos.y()+1, 00154 //this->simuPos.x()+1 00155 ); 00156 // In externen Dialog integrierte Simulation 00157 this->sd->canvasView->setDimension ( this->lg->numRows->value(), 00158 this->lg->numCols->value(), 00159 (this->lg->numRows->value()-1)/2, 00160 (this->lg->numCols->value()-1)/2 00161 //this->simuPos.y()+1, 00162 //this->simuPos.x()+1 00163 ); 00164 00165 // Netz neu initialisieren, wenn Parameter ver�ndert wurden 00166 } else if ((iHiddenUnits != iHiddenUnits_old) || 00167 (iHiddenLayers != iHiddenLayers_old)) { 00168 00169 // Thread beenden, wenn schon läuft 00170 if (this->pkt != NULL) { 00171 00172 DBG(); 00173 // Thread sicher beenden 00174 pkt->setModusFromExtern ('q'); 00175 while (pkt->running()); 00176 DBG(); 00177 00178 delete (pkt); 00179 } 00180 00181 // Neuen Thread erzeugen 00182 this->pkt = new ValueIterationThread ( 00183 (int)(this->lg->numCols->text().toInt()), 00184 (int)(this->lg->numRows->text().toInt()), 00185 this->gamma, 00186 speed, 00187 this->lg->netHiddenLayers->value(), 00188 this->lg->netHiddenUnits->value()); 00189 00190 this->pkt->setTrainRandomValues((int)((float)this->scalX * (float)this->scalY * 00191 (float)this->lg->viRandomValuesSlider->value() / (float)this->lg->viRandomValuesSlider->maxValue()) 00192 ); 00193 00194 00195 // Verbindung zum KI-Thread um richtig die Tabelle aktualisieren zu lassen 00196 connect( (QObject*)this->pkt, 00197 SIGNAL(emitValue(int, int, double, int)), 00198 (QObject*)this, 00199 SLOT(updatePolicyTable(int, int, double, int)) 00200 ); 00201 connect( (QObject*)this->pkt, 00202 SIGNAL(debugOutput(QString)), 00203 (QObject*)this, 00204 SLOT (debugOutput(QString)) 00205 ); 00206 connect( (QObject*)this->pkt, 00207 SIGNAL(emitNewNetworkError(double)), 00208 (QObject*)this, 00209 SLOT (adjust_network_error(double)) 00210 ); 00211 00212 } else if (dGamma != dGamma_old) { 00213 this->pkt->setGamma (dGamma); 00214 } 00215 00216 // Anzahl von Zeilen und Spalten speichern 00217 iCols_old = iCols; 00218 iRows_old = iRows; 00219 00220 // Netzvariablen speichern 00221 iHiddenUnits_old = iHiddenUnits; 00222 iHiddenLayers_old = iHiddenLayers; 00223 00224 // Network-Training Parameter anpassen 00225 this->pkt->setNetworkParameters( 00226 this->lg->netMaxEpochs->value(), 00227 this->lg->netIterationsBetweenReport->value(), 00228 this->lg->netDesiredError->text().toDouble(), 00229 dEta, 00230 this->lg->netAutoAdjustError->isChecked(), 00231 this->lg->netActivationStepnessHidden->text().toDouble(), 00232 this->lg->netActivationStepnessOutput->text().toDouble(), 00233 this->lg->netHiddenActivationFunction->currentItem(), 00234 this->lg->netOutputActivationFunction->currentItem() 00235 ); 00236 00237 int max; 00238 if(iCols> iRows) max = iCols; 00239 else max = iRows; 00240 00241 // GUI ist nun bereit 00242 this->guiReady = true; 00243 }
void LaufroboterDialog::debugOutput | ( | QString | _d | ) | [private, slot] |
Diese Funktion stellt einen Übergebenen String im Debug-Label dar.
_d | String zur Darstellung im Debug-Label |
Definiert in Zeile 130 der Datei gui_global.cpp.
Benutzt LaufroboterMainWindow::debugLabel und lg.
Wird benutzt von apply_button_clicked(), learn_method_nn_clicked(), learn_method_vi_clicked(), simulationWalk(), speed_slider_changed(), start_simulation_clicked(), stop_simulation_clicked() und vi_train_random_values_changed().
00130 { 00131 00132 lg->debugLabel->setText (_d); 00133 }
void LaufroboterDialog::delete_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 105 der Datei gui_simu_val_pol.cpp.
Benutzt DBG, guiMutex, lg, pkt, ValueIterationThread::setModusFromExtern(), stopLearningThread(), LaufroboterMainWindow::viIterationButton, LaufroboterMainWindow::viIterationButton2, LaufroboterMainWindow::viLernenButton, LaufroboterMainWindow::viLernenButton2, LaufroboterMainWindow::viStopButton und LaufroboterMainWindow::viStopButton2.
Wird benutzt von LaufroboterDialog().
00106 { 00107 DBG(); 00108 00109 // GUI sperren 00110 this->guiMutex->lock(); 00111 00112 this->stopLearningThread(); 00113 pkt->setModusFromExtern('c'); 00114 if (!this->pkt->running()) this->pkt->start(); 00115 00116 // Button wieder freigeben 00117 lg->viStopButton->setEnabled (false); 00118 lg->viLernenButton->setEnabled (true); 00119 lg->viIterationButton->setEnabled(true); 00120 lg->viStopButton2->setEnabled (false); 00121 lg->viLernenButton2->setEnabled (true); 00122 lg->viIterationButton2->setEnabled(true); 00123 00124 // GUI wieder freigeben 00125 this->guiMutex->unlock(); 00126 }
void LaufroboterDialog::feedbackClicked | ( | int | row, | |
int | col | |||
) | [private, slot] |
Funktion wird aufgerufen, wenn auf eine Zelle in der Feedback-Tabelle geklickt wurde
row | ||
col |
Definiert in Zeile 81 der Datei gui_feedback.cpp.
Benutzt DOWN, LaufroboterMainWindow::envColLabel, LaufroboterMainWindow::envDownRewardInput, LaufroboterMainWindow::envLeftRewardInput, LaufroboterMainWindow::envRightRewardInput, LaufroboterMainWindow::envRowLabel, LaufroboterMainWindow::envUpRewardInput, getReward(), LEFT, lg, RIGHT und UP.
Wird benutzt von apply_button_clicked().
00081 { 00082 00083 this->lg->envUpRewardInput->setValue( (int)getReward(row, col, UP) ); 00084 this->lg->envDownRewardInput->setValue( (int)getReward(row, col, DOWN) ); 00085 this->lg->envLeftRewardInput->setValue( (int)getReward(row, col, LEFT) ); 00086 this->lg->envRightRewardInput->setValue( (int)getReward(row, col, RIGHT) ); 00087 00088 this->lg->envRowLabel->setText(QString::number(row+1)); 00089 this->lg->envColLabel->setText(QString::number(col+1)); 00090 }
double LaufroboterDialog::getReward | ( | int | _row, | |
int | _column, | |||
int | _action | |||
) | [private] |
_row | ||
_column | ||
_action |
Definiert in Zeile 24 der Datei gui_feedback.cpp.
Benutzt feedbackMemory.
Wird benutzt von feedbackClicked(), save_button_clicked(), save_matlab_button_clicked(), updateFeedbackTable() und v24_copy_states_and_gamma_to_robot_button_clicked().
00024 { 00025 return this->feedbackMemory[_row][_column][_action]; 00026 }
void LaufroboterDialog::initDialog | ( | ) |
void LaufroboterDialog::iteration_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 6 der Datei gui_simu_val_pol.cpp.
Benutzt DBG, guiMutex, lg, LaufroboterMainWindow::netActivationStepnessHidden, LaufroboterMainWindow::netActivationStepnessOutput, LaufroboterMainWindow::netAutoAdjustError, LaufroboterMainWindow::netDesiredError, LaufroboterMainWindow::netEta, LaufroboterMainWindow::netHiddenActivationFunction, LaufroboterMainWindow::netIterationsBetweenReport, LaufroboterMainWindow::netMaxEpochs, LaufroboterMainWindow::netOutputActivationFunction, pkt, ValueIterationThread::setModusFromExtern(), ValueIterationThread::setNetworkParameters(), stopLearningThread() und LaufroboterMainWindow::viLearnWithNN.
Wird benutzt von LaufroboterDialog().
00006 { 00007 00008 DBG(); 00009 00010 // GUI sperren 00011 this->guiMutex->lock(); 00012 00013 this->stopLearningThread(); 00014 00015 // Kombination zwischen Value-Iteration+ Backpropagation 00016 if (this->lg->viLearnWithNN->isChecked()) { 00017 00018 // Network-Training Parameter anpassen 00019 this->pkt->setNetworkParameters( 00020 this->lg->netMaxEpochs->value(), 00021 this->lg->netIterationsBetweenReport->value(), 00022 this->lg->netDesiredError->text().toDouble(), 00023 this->lg->netEta->text().toDouble(), 00024 this->lg->netAutoAdjustError->isChecked(), 00025 this->lg->netActivationStepnessHidden->text().toDouble(), 00026 this->lg->netActivationStepnessOutput->text().toDouble(), 00027 this->lg->netHiddenActivationFunction->currentItem(), 00028 this->lg->netOutputActivationFunction->currentItem() 00029 ); 00030 00031 pkt->setModusFromExtern('b'); 00032 00033 // Value-Iteration mit Value-Memory im Hauptspeicher 00034 } else { 00035 pkt->setModusFromExtern('i'); 00036 } 00037 00038 00039 if (!this->pkt->running()) this->pkt->start(); 00040 00041 // GUI wieder freigeben 00042 this->guiMutex->unlock(); 00043 }
void LaufroboterDialog::learn_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 48 der Datei gui_simu_val_pol.cpp.
Benutzt DBG, guiMutex, lg, LaufroboterMainWindow::netActivationStepnessHidden, LaufroboterMainWindow::netActivationStepnessOutput, LaufroboterMainWindow::netAutoAdjustError, LaufroboterMainWindow::netDesiredError, LaufroboterMainWindow::netEta, LaufroboterMainWindow::netHiddenActivationFunction, LaufroboterMainWindow::netIterationsBetweenReport, LaufroboterMainWindow::netMaxEpochs, LaufroboterMainWindow::netOutputActivationFunction, pkt, ValueIterationThread::setModusFromExtern(), ValueIterationThread::setNetworkParameters(), ValueIterationThread::setSpeed(), speed, stopLearningThread(), LaufroboterMainWindow::viDeleteButton, LaufroboterMainWindow::viDeleteButton2, LaufroboterMainWindow::viIterationButton, LaufroboterMainWindow::viIterationButton2, LaufroboterMainWindow::viLearnWithNN, LaufroboterMainWindow::viLernenButton, LaufroboterMainWindow::viLernenButton2, LaufroboterMainWindow::viSpeedSlider, LaufroboterMainWindow::viStopButton und LaufroboterMainWindow::viStopButton2.
Wird benutzt von LaufroboterDialog().
00049 { 00050 DBG(); 00051 00052 // GUI sperren 00053 this->guiMutex->lock(); 00054 00055 // Geschwindigkeit setzen 00056 speed = this->lg->viSpeedSlider->maxValue() - this->lg->viSpeedSlider->value(); 00057 pkt->setSpeed (speed); 00058 00059 this->stopLearningThread(); 00060 00061 // Kombination zwischen Value-Iteration+ Backpropagation 00062 if (this->lg->viLearnWithNN->isChecked()) { 00063 00064 // Network-Training Parameter anpassen 00065 this->pkt->setNetworkParameters( 00066 this->lg->netMaxEpochs->value(), 00067 this->lg->netIterationsBetweenReport->value(), 00068 this->lg->netDesiredError->text().toDouble(), 00069 this->lg->netEta->text().toDouble(), 00070 this->lg->netAutoAdjustError->isChecked(), 00071 this->lg->netActivationStepnessHidden->text().toDouble(), 00072 this->lg->netActivationStepnessOutput->text().toDouble(), 00073 this->lg->netHiddenActivationFunction->currentItem(), 00074 this->lg->netOutputActivationFunction->currentItem() 00075 ); 00076 00077 pkt->setModusFromExtern('B'); 00078 00079 // Pures Value-Iteration mit speicherung der Values in 00080 } else { 00081 pkt->setModusFromExtern('l'); 00082 } 00083 00084 00085 if (!this->pkt->running()) this->pkt->start(); 00086 00087 lg->viLernenButton->setEnabled (false); 00088 lg->viIterationButton->setEnabled (false); 00089 lg->viStopButton->setEnabled (true); 00090 lg->viDeleteButton->setEnabled (false); 00091 lg->viLernenButton2->setEnabled (false); 00092 lg->viIterationButton2->setEnabled (false); 00093 lg->viStopButton2->setEnabled (true); 00094 lg->viDeleteButton2->setEnabled (false); 00095 00096 lg->viSpeedSlider->setEnabled (true); 00097 00098 // GUI wieder freigeben 00099 this->guiMutex->unlock(); 00100 }
void LaufroboterDialog::learn_method_nn_clicked | ( | ) | [private, slot] |
Definiert in Zeile 236 der Datei gui_simu_val_pol.cpp.
Benutzt ValueIterationThread::activateNet(), DBG, debugOutput(), guiMutex, lg, pkt, ValueIterationThread::setModusFromExtern(), stopLearningThread(), LaufroboterMainWindow::viLearnWithNN und LaufroboterMainWindow::viLearnWithVI.
Wird benutzt von LaufroboterDialog().
00236 { 00237 00238 DBG(); 00239 00240 // GUI sperren 00241 this->guiMutex->lock(); 00242 00243 // Alle laufenden Aktionen anhalten 00244 this->stopLearningThread(); 00245 this->pkt->activateNet(); 00246 this->pkt->setModusFromExtern('p'); 00247 if (!this->pkt->running()) this->pkt->start(); 00248 00249 debugOutput ("neural network activated"); 00250 00251 this->lg->viLearnWithNN->setEnabled(false); 00252 this->lg->viLearnWithVI->setEnabled(true); 00253 this->lg->viLearnWithNN->setChecked(true); 00254 this->lg->viLearnWithVI->setChecked(false); 00255 00256 // GUI wieder freigeben 00257 this->guiMutex->unlock(); 00258 }
void LaufroboterDialog::learn_method_vi_clicked | ( | ) | [private, slot] |
Definiert in Zeile 263 der Datei gui_simu_val_pol.cpp.
Benutzt DBG, ValueIterationThread::deactivateNet(), debugOutput(), guiMutex, lg, pkt, ValueIterationThread::setModusFromExtern(), stopLearningThread(), LaufroboterMainWindow::viLearnWithNN und LaufroboterMainWindow::viLearnWithVI.
Wird benutzt von apply_button_clicked() und LaufroboterDialog().
00263 { 00264 00265 DBG(); 00266 00267 // GUI sperren 00268 this->guiMutex->lock(); 00269 00270 // Alle laufenden Aktionen anhalten 00271 this->stopLearningThread(); 00272 this->pkt->deactivateNet(); 00273 this->pkt->setModusFromExtern('p'); 00274 if (!this->pkt->running()) this->pkt->start(); 00275 00276 debugOutput ("neural network deactivated"); 00277 00278 this->lg->viLearnWithNN->setEnabled(true); 00279 this->lg->viLearnWithVI->setEnabled(false); 00280 this->lg->viLearnWithNN->setChecked(false); 00281 this->lg->viLearnWithVI->setChecked(true); 00282 00283 // GUI wieder freigeben 00284 this->guiMutex->unlock(); 00285 }
void LaufroboterDialog::learn_method_vi_nn_clicked | ( | ) | [private, slot] |
Definiert in Zeile 290 der Datei gui_simu_val_pol.cpp.
Benutzt ValueIterationThread::activateNet(), DBG, guiMutex, lg, pkt, ValueIterationThread::setModusFromExtern(), stopLearningThread(), LaufroboterMainWindow::viLearnWithNN und LaufroboterMainWindow::viLearnWithVI.
00290 { 00291 00292 DBG(); 00293 00294 // GUI sperren 00295 this->guiMutex->lock(); 00296 00297 // Alle laufenden Aktionen anhalten 00298 this->stopLearningThread(); 00299 this->pkt->activateNet(); 00300 this->pkt->setModusFromExtern('p'); 00301 if (!this->pkt->running()) this->pkt->start(); 00302 00303 this->lg->viLearnWithNN->setEnabled(true); 00304 this->lg->viLearnWithVI->setEnabled(true); 00305 this->lg->viLearnWithNN->setChecked(false); 00306 this->lg->viLearnWithVI->setChecked(false); 00307 00308 00309 // GUI wieder freigeben 00310 this->guiMutex->unlock(); 00311 }
void LaufroboterDialog::load_button_clicked | ( | ) | [private, slot] |
Funktion wird aufgerufen, wenn auf "load from file" geklickt wurde
Definiert in Zeile 220 der Datei gui_feedback.cpp.
Benutzt LaufroboterMainWindow::debugLabel, DOWN, feedbackMemory, LEFT, lg, LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, pkt, RIGHT, ValueIterationThread::setFeedback(), UP und updateFeedbackTable().
Wird benutzt von LaufroboterDialog().
00220 { 00221 00222 QString s = QFileDialog::getOpenFileName( 00223 ".", 00224 "Feedback (*.feedback);;All files(*.*)", 00225 this, 00226 "open file dialog", 00227 "Choose a file" ); 00228 00229 this->lg->debugLabel->setText("load button: " + s); 00230 00231 QFile qf(s); 00232 Q_INT32 _up, _down, _left, _right, _rows, _cols; 00233 00234 if ( qf.open(IO_ReadOnly) ) { 00235 QDataStream stream( &qf ); // we will serialize the data into the file 00236 00237 //Header lesen mit Anzahl von Zeilen und Spalten 00238 stream >> _rows >> _cols; 00239 00240 if (_rows != this->lg->numRows->text().toInt() || 00241 _cols != this->lg->numCols->text().toInt()) { 00242 QMessageBox::critical( this, "Laufroboter Dialog", 00243 "Your " + this->lg->numRows->text() + "x" + 00244 this->lg->numCols->text() + " matrix, doesn't fit with a " + 00245 QString::number(_rows) + "x" + QString::number(_cols) + 00246 " matrix, \nwhich is hold inside your selected file. \n\n" + s); 00247 } else { 00248 00249 for (int row=0; row < this->lg->numRows->text().toInt(); row++) { 00250 for (int col=0; col < this->lg->numCols->text().toInt(); col++) { 00251 stream >> _up >> _down >> _left >> _right; 00252 this->feedbackMemory[row][col][UP] = _up; 00253 this->feedbackMemory[row][col][DOWN] = _down; 00254 this->feedbackMemory[row][col][LEFT] = _left; 00255 this->feedbackMemory[row][col][RIGHT] = _right; 00256 updateFeedbackTable(row, col, _up, _down, _left, _right); 00257 this->pkt->setFeedback(row, col, _up, _down, _left, _right); 00258 } 00259 } 00260 } 00261 qf.close(); 00262 } else { 00263 this->lg->debugLabel->setText("ERROR: Could not read from file: " + s); 00264 } 00265 }
void LaufroboterDialog::resume_simulation_clicked | ( | ) | [private, slot] |
Definiert in Zeile 45 der Datei gui_simu_simu.cpp.
Benutzt lg, SimulationDialogUI::resumeSimulationButton, LaufroboterMainWindow::resumeSimulationButton, sd, st, SimulationDialogUI::startSimulationButton, LaufroboterMainWindow::startSimulationButton, SimulationDialogUI::stopSimulationButton und LaufroboterMainWindow::stopSimulationButton.
Wird benutzt von LaufroboterDialog().
00045 { 00046 // Buttons en- und disablen 00047 this->lg->startSimulationButton->setEnabled(false); 00048 this->lg->stopSimulationButton->setEnabled(true); 00049 this->lg->resumeSimulationButton->setEnabled(false); 00050 this->sd->startSimulationButton->setEnabled(false); 00051 this->sd->stopSimulationButton->setEnabled(true); 00052 this->sd->resumeSimulationButton->setEnabled(false); 00053 // Timer starten um automatisch in den nächsten Zustand zu wechseln 00054 this->st->start(1000, 0); 00055 }
void LaufroboterDialog::save_button_clicked | ( | ) | [private, slot] |
Funktion wird aufgerufen, wenn auf "save to file" geklickt wurde
Definiert in Zeile 140 der Datei gui_feedback.cpp.
Benutzt LaufroboterMainWindow::debugLabel, DOWN, getReward(), LEFT, lg, LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, RIGHT und UP.
Wird benutzt von LaufroboterDialog().
00140 { 00141 00142 QString s = QFileDialog::getSaveFileName( 00143 ".", 00144 "Feedback (*.feedback);;All files(*.*)", 00145 this, 00146 "open file dialog", 00147 "Choose a file" ); 00148 00149 this->lg->debugLabel->setText("save button: " + s); 00150 00151 QFile qf(s); 00152 if ( qf.open(IO_WriteOnly) ) { 00153 00154 QDataStream stream( &qf ); // we will serialize the data into the file 00155 00156 //Header schreiben mit Anzahl von Zeilen und Spalten 00157 stream << (Q_INT32)this->lg->numRows->text().toInt() 00158 << (Q_INT32)this->lg->numCols->text().toInt(); 00159 00160 for (int i=0; i < this->lg->numRows->text().toInt(); i++) { 00161 for (int j=0; j < this->lg->numCols->text().toInt(); j++) { 00162 stream << (Q_INT32)getReward(i, j, UP) 00163 << (Q_INT32)getReward(i, j, DOWN) 00164 << (Q_INT32)getReward(i, j, LEFT) 00165 << (Q_INT32)getReward(i, j, RIGHT); 00166 } 00167 } 00168 qf.close(); 00169 } else { 00170 QMessageBox::critical( this, "Laufroboter Dialog", "ERROR: Could not write to file: " + s); 00171 } 00172 00173 }
void LaufroboterDialog::save_feedback_clicked | ( | ) | [private, slot] |
Funktion wird aufgerufen, wenn auf "save feedback" geklickt wurde
Definiert in Zeile 97 der Datei gui_feedback.cpp.
Benutzt DOWN, LaufroboterMainWindow::envDownRewardInput, LaufroboterMainWindow::envLeftRewardInput, LaufroboterMainWindow::envRewardTable, LaufroboterMainWindow::envRightRewardInput, LaufroboterMainWindow::envUpRewardInput, feedbackMemory, LEFT, lg, pkt, RIGHT, ValueIterationThread::setFeedback(), UP und updateFeedbackTable().
Wird benutzt von LaufroboterDialog().
00097 { 00098 int _row, _col; 00099 00100 int _up = this->lg->envUpRewardInput->value(); 00101 int _down = this->lg->envDownRewardInput->value(); 00102 int _left = this->lg->envLeftRewardInput->value(); 00103 int _right = this->lg->envRightRewardInput->value(); 00104 00105 00106 // Alle Zellen checken, ob sie jeweils selektiert sind 00107 for (int i=0; i < this->lg->envRewardTable->numRows(); i++) { 00108 for (int j=0; j < this->lg->envRewardTable->numCols(); j++) { 00109 if (this->lg->envRewardTable->isSelected(i,j)) { 00110 00111 _row = i; 00112 _col = j; 00113 00114 // Feedback-Memory aktualisieren 00115 this->feedbackMemory[_row][_col][UP] = _up; 00116 this->feedbackMemory[_row][_col][DOWN] = _down; 00117 this->feedbackMemory[_row][_col][LEFT] = _left; 00118 this->feedbackMemory[_row][_col][RIGHT] = _right; 00119 00120 updateFeedbackTable ( _row, _col, _up, _down, _left, _right); 00121 00122 this->pkt->setFeedback( _row, _col, _up, _down, _left, _right); 00123 } 00124 } 00125 } 00126 00127 // Breite und H�he der Zellen anpassen 00128 for (int i=0; i < this->lg->envRewardTable->numRows(); i++) { 00129 lg->envRewardTable->adjustRow (i); 00130 } 00131 00132 for (int j=0; j < this->lg->envRewardTable->numCols(); j++) { 00133 lg->envRewardTable->adjustColumn (j); 00134 } 00135 }
void LaufroboterDialog::save_matlab_button_clicked | ( | ) | [private, slot] |
Funktion wird aufgerufen, wenn auf "save to file" geklickt wurde
Definiert in Zeile 178 der Datei gui_feedback.cpp.
Benutzt LaufroboterMainWindow::debugLabel, DOWN, getReward(), LEFT, lg, LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, RIGHT und UP.
Wird benutzt von LaufroboterDialog().
00178 { 00179 00180 char zeile[256]; 00181 00182 QString s = QFileDialog::getSaveFileName( 00183 ".", 00184 "Matlab/Octave (*.m);;All files(*.*)", 00185 this, 00186 "open file dialog", 00187 "Choose a file" ); 00188 00189 this->lg->debugLabel->setText("save matlab button: " + s); 00190 00191 QFile qf(s); 00192 if ( qf.open(IO_WriteOnly) ) { 00193 00194 //Header schreiben mit Anzahl von Zeilen und Spalten 00195 sprintf (zeile, "envRows=%d;\nenvCols=%d;\n", this->lg->numRows->text().toInt(), this->lg->numCols->text().toInt()); 00196 qf.writeBlock(zeile, strlen(zeile)); 00197 00198 for (int i=0; i < this->lg->numRows->text().toInt(); i++) { 00199 for (int j=0; j < this->lg->numCols->text().toInt(); j++) { 00200 sprintf (zeile, "env{%d} = [%f, %f, %f, %f];\n", 00201 ((i*this->lg->numCols->text().toInt()) + j + 1), 00202 getReward(i, j, UP), 00203 getReward(i, j, DOWN), 00204 getReward(i, j, LEFT), 00205 getReward(i, j, RIGHT)); 00206 qf.writeBlock(zeile, strlen(zeile)); 00207 } 00208 } 00209 qf.close(); 00210 } else { 00211 QMessageBox::critical( this, "Laufroboter Dialog", "ERROR: Could not write to file: " + s); 00212 } 00213 00214 }
void LaufroboterDialog::setReward | ( | int | _row, | |
int | _column, | |||
int | _action, | |||
double | _reward | |||
) | [private] |
Funktion setzt das Feedback für einen Zustand entweder im RAM oder im neuronalen Netz
_row | ||
_colum | ||
_action | ||
_reward |
Definiert in Zeile 13 der Datei gui_feedback.cpp.
Benutzt feedbackMemory.
Wird benutzt von updateFeedbackTable().
00013 { 00014 00015 this->feedbackMemory[_row][_column][_action] = _reward; 00016 }
void LaufroboterDialog::simulationWalk | ( | ) | [private, slot] |
Definiert in Zeile 74 der Datei gui_simu_simu.cpp.
Benutzt action, SimulationDialogUI::canvasView, LaufroboterMainWindow::canvasView, debugOutput(), DOWN, LEFT, lg, MyCanvasView::moveRobot(), RIGHT, sd, simuPos, simuPosNew, st und UP.
Wird benutzt von LaufroboterDialog().
00074 { 00075 00076 //Thread während der Operation anhalten 00077 this->st->stop(); 00078 00079 // Aktuelle Position steht in this->simuPos 00080 // Neue Position steht in this->simuPosNeu 00081 if (this->action[simuPos.y()][simuPos.x()] == UP) { 00082 this->simuPosNew.setX( this->simuPos.x()); 00083 this->simuPosNew.setY( this->simuPos.y() -1 ); 00084 } 00085 else if (this->action[simuPos.y()][simuPos.x()] == DOWN) { 00086 this->simuPosNew.setX( this->simuPos.x()); 00087 this->simuPosNew.setY( this->simuPos.y() +1 ); 00088 } 00089 else if (this->action[simuPos.y()][simuPos.x()] == LEFT) { 00090 this->simuPosNew.setX( this->simuPos.x() -1); 00091 this->simuPosNew.setY( this->simuPos.y()); 00092 } 00093 else if (this->action[simuPos.y()][simuPos.x()] == RIGHT) { 00094 this->simuPosNew.setX( this->simuPos.x() +1); 00095 this->simuPosNew.setY( this->simuPos.y()); 00096 } 00097 00098 this->simuPos = this->simuPosNew; 00099 00100 // In GUI integrierte Simulation 00101 this->lg->canvasView->moveRobot (this->simuPos.y()+1, this->simuPos.x()+1); 00102 // In externen Dialog integrierte Simulation 00103 this->sd->canvasView->moveRobot (this->simuPos.y()+1, this->simuPos.x()+1); 00104 this->sd->show(); 00105 00106 this->debugOutput ("Position: Row=" + QString::number(this->simuPos.y() +1) + 00107 ", Column=" + QString::number(this->simuPos.x() +1) ); 00108 00109 //Thread wieder weiterlaufen lassen 00110 this->st->start(1000, 0); 00111 }
void LaufroboterDialog::speed_slider_changed | ( | int | _value | ) | [private, slot] |
_value |
Definiert in Zeile 175 der Datei gui_simu_val_pol.cpp.
Benutzt debugOutput(), lg, pkt, ValueIterationThread::setSpeed(), speed, LaufroboterMainWindow::viSpeedLabel und LaufroboterMainWindow::viSpeedSlider.
Wird benutzt von apply_button_clicked().
00175 { 00176 speed = this->lg->viSpeedSlider->maxValue() - _value; 00177 pkt->setSpeed (speed); 00178 debugOutput ("Neue Geschwindigkeit: " + QString::number (speed)); 00179 this->lg->viSpeedLabel->setText ("speed (" + QString::number (speed) + "): slow"); 00180 }
void LaufroboterDialog::start_simulation_clicked | ( | ) | [private, slot] |
Definiert in Zeile 6 der Datei gui_simu_simu.cpp.
Benutzt SimulationDialogUI::canvasView, LaufroboterMainWindow::canvasView, debugOutput(), lg, LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, SimulationDialogUI::resumeSimulationButton, LaufroboterMainWindow::resumeSimulationButton, sd, MyCanvasView::setDimension(), simuPos, st, SimulationDialogUI::startSimulationButton, LaufroboterMainWindow::startSimulationButton, SimulationDialogUI::stopSimulationButton und LaufroboterMainWindow::stopSimulationButton.
Wird benutzt von LaufroboterDialog().
00006 { 00007 00008 // Buttons en- und disablen (lg=lokale Ansicht; sd=externe Ansicht) 00009 this->lg->startSimulationButton->setEnabled(false); 00010 this->lg->stopSimulationButton->setEnabled(true); 00011 this->lg->resumeSimulationButton->setEnabled(false); 00012 this->sd->startSimulationButton->setEnabled(false); 00013 this->sd->stopSimulationButton->setEnabled(true); 00014 this->sd->resumeSimulationButton->setEnabled(false); 00015 this->debugOutput("start simulation"); 00016 00017 // Roboter in Grundposition bringen 00018 this->simuPos.setX(0); 00019 this->simuPos.setY(0); 00020 00021 // In GUI integrierte Simulation 00022 this->lg->canvasView->setDimension ( this->lg->numRows->value(), 00023 this->lg->numCols->value(), 00024 this->simuPos.y()+1, 00025 this->simuPos.x()+1 00026 ); 00027 00028 // In externen Dialog integrierte Simulation 00029 this->sd->canvasView->setDimension ( this->lg->numRows->value(), 00030 this->lg->numCols->value(), 00031 this->simuPos.y()+1, 00032 this->simuPos.x()+1 00033 ); 00034 00035 // externen Dialog sichtbar machen 00036 this->sd->show(); 00037 00038 // Timer starten um automatisch in den nächsten Zustand wechseln zu können 00039 this->st->start(1000, 0); 00040 }
void LaufroboterDialog::stop_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 131 der Datei gui_simu_val_pol.cpp.
Benutzt DBG, guiMutex, lg, stopLearningThread(), LaufroboterMainWindow::viDeleteButton, LaufroboterMainWindow::viDeleteButton2, LaufroboterMainWindow::viIterationButton, LaufroboterMainWindow::viIterationButton2, LaufroboterMainWindow::viLernenButton, LaufroboterMainWindow::viLernenButton2, LaufroboterMainWindow::viStopButton und LaufroboterMainWindow::viStopButton2.
Wird benutzt von LaufroboterDialog().
00131 { 00132 00133 DBG(); 00134 00135 // GUI sperren 00136 this->guiMutex->lock(); 00137 00138 this->stopLearningThread(); 00139 // Button wieder freigeben 00140 lg->viStopButton->setEnabled (false); 00141 lg->viDeleteButton->setEnabled (true); 00142 lg->viLernenButton->setEnabled (true); 00143 lg->viIterationButton->setEnabled (true); 00144 lg->viStopButton2->setEnabled (false); 00145 lg->viDeleteButton2->setEnabled (true); 00146 lg->viLernenButton2->setEnabled (true); 00147 lg->viIterationButton2->setEnabled (true); 00148 00149 // GUI wieder freigeben 00150 this->guiMutex->unlock(); 00151 }
void LaufroboterDialog::stop_simulation_clicked | ( | ) | [private, slot] |
Definiert in Zeile 60 der Datei gui_simu_simu.cpp.
Benutzt debugOutput(), lg, SimulationDialogUI::resumeSimulationButton, LaufroboterMainWindow::resumeSimulationButton, sd, st, SimulationDialogUI::startSimulationButton, LaufroboterMainWindow::startSimulationButton, SimulationDialogUI::stopSimulationButton und LaufroboterMainWindow::stopSimulationButton.
Wird benutzt von LaufroboterDialog().
00060 { 00061 this->debugOutput("stop simulation"); 00062 this->st->stop(); 00063 this->lg->startSimulationButton->setEnabled(true); 00064 this->lg->stopSimulationButton->setEnabled(false); 00065 this->lg->resumeSimulationButton->setEnabled(true); 00066 this->sd->startSimulationButton->setEnabled(true); 00067 this->sd->stopSimulationButton->setEnabled(false); 00068 this->sd->resumeSimulationButton->setEnabled(true); 00069 }
void LaufroboterDialog::stopLearningThread | ( | ) | [private, slot] |
Definiert in Zeile 138 der Datei gui_global.cpp.
Benutzt DBG, pkt und ValueIterationThread::setModusFromExtern().
Wird benutzt von delete_button_clicked(), iteration_button_clicked(), learn_button_clicked(), learn_method_nn_clicked(), learn_method_vi_clicked(), learn_method_vi_nn_clicked(), stop_button_clicked(), v24_copy_states_and_gamma_to_robot_button_clicked() und v24_get_states_and_gamma_from_robot_button_clicked().
00138 { 00139 DBG(); 00140 if (this->pkt != NULL) { 00141 pkt->setModusFromExtern('p'); 00142 } 00143 }
void LaufroboterDialog::updateFeedbackTable | ( | int | _row, | |
int | _column, | |||
double | _up, | |||
double | _down, | |||
double | _left, | |||
double | _right | |||
) | [private, slot] |
Funktion zum updaten der Feedback-Tabelle
_row | ||
_column | ||
_up | ||
_down | ||
_left | ||
_right |
Definiert in Zeile 37 der Datei gui_feedback.cpp.
Benutzt dad, DOWN, LaufroboterMainWindow::envRewardTable, getReward(), i_cell, LEFT, lg, LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, pkt, RIGHT, setReward(), ValueIterationThread::unlockMutex() und UP.
Wird benutzt von load_button_clicked(), save_feedback_clicked() und v24_get_states_and_gamma_from_robot_button_clicked().
00037 { 00038 00039 QTableItem *feedback_item; 00040 static int updateCall = 0; 00041 00042 this->dad->lock(); 00043 00044 00045 // Feedback-Memory aktualisieren 00046 setReward(_row, _column, UP, _up); 00047 setReward(_row, _column, DOWN, _down); 00048 setReward(_row, _column, LEFT, _left); 00049 setReward(_row, _column, RIGHT, _right); 00050 00051 // Feedback-Tabellen Item 00052 feedback_item = lg->envRewardTable->item (_row, _column); 00053 feedback_item->setText (" " + QString::number ((float)getReward(_row, _column, UP)) + "\n" + 00054 QString::number ((float)getReward(_row, _column, LEFT)) + 00055 " " + QString::number ((float)getReward(_row, _column, RIGHT)) + "\n" + 00056 " " + QString::number ((float)getReward(_row, _column, DOWN))); 00057 00058 updateCall++; 00059 if (updateCall == i_cell ) { 00060 for (int i=0; i < lg->numRows->text().toInt(); i++) { 00061 lg->envRewardTable->adjustRow (i); 00062 } 00063 for (int i=0; i < lg->numCols->text().toInt(); i++) { 00064 lg->envRewardTable->adjustColumn (i); 00065 } 00066 updateCall = 0; 00067 } 00068 00069 this->pkt->unlockMutex(); 00070 00071 // GUI-Mutex wieder freigeben 00072 this->dad->unlock(); 00073 }
void LaufroboterDialog::updatePolicyTable | ( | int | _row, | |
int | _column, | |||
double | _value, | |||
int | _bestdirection | |||
) | [private, slot] |
_row | ||
_column | ||
_value | ||
_bestdirection |
Definiert in Zeile 189 der Datei gui_simu_val_pol.cpp.
Benutzt action, dad, fValueMemory, i_cell, iMantisse, lg, LaufroboterMainWindow::numCols, pix, pkt, LaufroboterMainWindow::strategyTable, ValueIterationThread::unlockMutex() und LaufroboterMainWindow::viValueTable.
Wird benutzt von apply_button_clicked() und v24_get_states_and_gamma_from_robot_button_clicked().
00189 { 00190 00191 QTableItem *strategy_item, *value_item; 00192 static int updateCall = 0; 00193 00194 this->dad->lock(); 00195 00196 // Aktion speichern 00197 this->action[_row][_column] = _bestdirection; 00198 00199 //Value Table 00200 value_item = lg->viValueTable->item (_row, _column); 00201 value_item->setPixmap (pix[_bestdirection]); 00202 value_item->setText (QString::number (_value, 'f', iMantisse)); 00203 00204 // Value-Memory aktualisieren 00205 fValueMemory[_row][_column] = (float) _value; 00206 00207 //Strategy-Table 00208 strategy_item = lg->strategyTable->item (_row, _column); 00209 00210 strategy_item->setPixmap (pix[_bestdirection]); 00211 00212 00213 // Aller (x * y) Aufrufe die Tabelle an die Größe anpassen 00214 updateCall++; 00215 00216 if (updateCall == i_cell ) { 00217 for (int i=0; i < lg->numCols->text().toInt(); i++) { 00218 lg->viValueTable->adjustColumn (i); 00219 lg->strategyTable->adjustColumn (i); 00220 } 00221 lg->viValueTable->updateCell(_row, _column); 00222 lg->strategyTable->updateCell(_row, _column); 00223 00224 updateCall = 0; 00225 } 00226 00227 this->pkt->unlockMutex(); 00228 00229 // GUI-Mutex wieder freigeben 00230 this->dad->unlock(); 00231 }
void LaufroboterDialog::v24_accept_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 218 der Datei gui_v24.cpp.
Benutzt lg, V24Control::setInterface(), v24, LaufroboterMainWindow::v24CopyStatesAndGammaToRobotButton, LaufroboterMainWindow::v24DebugButton, LaufroboterMainWindow::v24ExplorationAcceptButton, LaufroboterMainWindow::v24ExplorationParameterInput, LaufroboterMainWindow::v24ExploreFeedbackButton, LaufroboterMainWindow::v24GetDistanceButton, LaufroboterMainWindow::v24GetExplorationButton, LaufroboterMainWindow::v24GetPositionAndModeButton, LaufroboterMainWindow::v24GetStatesAndGammaFromRobotButton, LaufroboterMainWindow::v24RamtestButton, LaufroboterMainWindow::v24ResetDistanceButton, LaufroboterMainWindow::v24StartLearningButton, LaufroboterMainWindow::v24StartWalkingButton und LaufroboterMainWindow::v24StopWalkingButton.
Wird benutzt von LaufroboterDialog().
00218 { 00219 00220 if (v24->setInterface(this->lg->v24Interface->text())) { 00221 this->lg->v24StartWalkingButton->setEnabled(true); 00222 this->lg->v24StartLearningButton->setEnabled(true); 00223 this->lg->v24StopWalkingButton->setEnabled(true); 00224 this->lg->v24CopyStatesAndGammaToRobotButton->setEnabled(true); 00225 this->lg->v24GetStatesAndGammaFromRobotButton->setEnabled(true); 00226 this->lg->v24GetPositionAndModeButton->setEnabled(true); 00227 this->lg->v24RamtestButton->setEnabled(true); 00228 this->lg->v24ExploreFeedbackButton->setEnabled(true); 00229 this->lg->v24GetDistanceButton->setEnabled(true); 00230 this->lg->v24ExplorationAcceptButton->setEnabled(true); 00231 this->lg->v24GetExplorationButton->setEnabled(true); 00232 this->lg->v24ExplorationParameterInput->setEnabled(true); 00233 this->lg->v24ResetDistanceButton->setEnabled(true); 00234 this->lg->v24DebugButton->setEnabled(true); 00235 } else { 00236 this->lg->v24StartWalkingButton->setEnabled(false); 00237 this->lg->v24StartLearningButton->setEnabled(false); 00238 this->lg->v24StopWalkingButton->setEnabled(false); 00239 this->lg->v24CopyStatesAndGammaToRobotButton->setEnabled(false); 00240 this->lg->v24GetStatesAndGammaFromRobotButton->setEnabled(false); 00241 this->lg->v24GetPositionAndModeButton->setEnabled(false); 00242 this->lg->v24RamtestButton->setEnabled(false); 00243 this->lg->v24ExploreFeedbackButton->setEnabled(false); 00244 this->lg->v24GetDistanceButton->setEnabled(false); 00245 this->lg->v24ExplorationAcceptButton->setEnabled(false); 00246 this->lg->v24GetExplorationButton->setEnabled(false); 00247 this->lg->v24ExplorationParameterInput->setEnabled(false); 00248 this->lg->v24ResetDistanceButton->setEnabled(false); 00249 this->lg->v24DebugButton->setEnabled(false); 00250 } 00251 }
void LaufroboterDialog::v24_copy_states_and_gamma_to_robot_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 356 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::data, V24Command::dataLength, DOWN, State::feedback_down, State::feedback_left, State::feedback_right, State::feedback_up, fValueMemory, gamma, getReward(), LEFT, lg, V24Control::receiveTransmitOKCommand(), RIGHT, scalX, scalY, STATESIZE, stopLearningThread(), V24Control::transmitCommand(), UP, v24, V24_COMMAND_SET_ALL_STATES_AND_GAMMA, V24_COMMAND_SET_GAMMA, V24_COMMAND_SET_GRIDSIZE, V24_COMMAND_SET_STATE, LaufroboterMainWindow::v24Data und State::value.
Wird benutzt von LaufroboterDialog().
00356 { 00357 00358 V24COMMAND c; 00359 unsigned char* _bytes; 00360 State _state; 00361 00362 this->stopLearningThread(); 00363 00364 // Kommando für Bulk-Anfrage schicken 00365 c.command = V24_COMMAND_SET_ALL_STATES_AND_GAMMA; 00366 c.dataLength = 0; 00367 00368 // Kommando über V24 senden 00369 if (!v24->transmitCommand(&c)) { 00370 v24->closeDevice(); 00371 this->lg->v24Data->setText("!!transmit error!!"); 00372 return; 00373 } 00374 00375 /**************************** 00376 * Gamma schicken * 00377 ****************************/ 00378 c.command = V24_COMMAND_SET_GAMMA; 00379 c.dataLength = sizeof(this->gamma); 00380 _bytes = (unsigned char*) γ 00381 for (int i=0; i < c.dataLength; i++) { 00382 c.data[i] = _bytes[i]; 00383 } 00384 00385 // Befehl schicken um Gamma zu setzen 00386 if (!v24->transmitCommand(&c)) { 00387 v24->closeDevice(); 00388 this->lg->v24Data->setText("!!transmit error!!"); 00389 return; 00390 } 00391 if (!v24->receiveTransmitOKCommand()) { 00392 v24->closeDevice(); 00393 this->lg->v24Data->setText("!!transmit error!!"); 00394 return; 00395 } 00396 00397 /***************************** 00398 * Grid-Größe schicken * 00399 *****************************/ 00400 c.command = V24_COMMAND_SET_GRIDSIZE; 00401 c.dataLength = 2; 00402 c.data[0] = (unsigned char)scalY; // anzahl der spalten 00403 c.data[1] = (unsigned char)scalX; // anzahl der zeilen 00404 00405 // Befehl schicken um Grid-Größe zu setzen 00406 if (!v24->transmitCommand(&c)) { 00407 v24->closeDevice(); 00408 this->lg->v24Data->setText("!!transmit error!!"); 00409 return; 00410 } 00411 if (!v24->receiveTransmitOKCommand()) { 00412 v24->closeDevice(); 00413 this->lg->v24Data->setText("!!transmit error!!"); 00414 return; 00415 } 00416 00417 00418 /*************************************** 00419 * Values+Feedbacks-schicken schicken * 00420 ***************************************/ 00421 c.command = V24_COMMAND_SET_STATE; 00422 c.dataLength = STATESIZE+2; 00423 00424 //int _row=0, _column=0; 00425 for (int _row=0; _row < this->scalY; _row++) { 00426 for (int _column=0; _column < this->scalX; _column++) { 00427 00428 // Position in Puffer schreiben 00429 c.data[0] = (unsigned char)_row; 00430 c.data[1] = (unsigned char)_column; 00431 00432 // Zustand mit Daten befüllen 00433 _state.value = (float)fValueMemory[_row][_column]; 00434 //_state.best_action = (unsigned char)aktion[_row][_column]; 00435 _state.feedback_up = (char)getReward(_row, _column, UP); 00436 _state.feedback_down = (char)getReward(_row, _column, DOWN); 00437 _state.feedback_left = (char)getReward(_row, _column, LEFT); 00438 _state.feedback_right = (char)getReward(_row, _column, RIGHT); 00439 00440 // Zustand dem Puffer hinzufügen 00441 _bytes = (unsigned char*)&_state; 00442 for (int i=0; i < STATESIZE; i++) { 00443 c.data[2 + i] = _bytes[i]; 00444 } 00445 00446 // Zustand �ber V24 senden 00447 if (!v24->transmitCommand(&c)) { 00448 v24->closeDevice(); 00449 this->lg->v24Data->setText("!!receive error!!"); 00450 return; 00451 } 00452 00453 // Okey abwarten, bis n�chstes Kommando gesendet werden kann 00454 if (!v24->receiveTransmitOKCommand()) { 00455 v24->closeDevice(); 00456 this->lg->v24Data->setText("!!receive error!!"); 00457 return; 00458 } 00459 } 00460 } 00461 00462 // Okey abwarten, bis nächstes Kommando gesendet werden kann 00463 /*if (!v24->receiveTransmitOKCommand()) { 00464 v24->closeDevice(); 00465 return; 00466 }*/ 00467 00468 v24->closeDevice(); 00469 00470 this->lg->v24Data->setText("Configuration successfully applied..."); 00471 }
void LaufroboterDialog::v24_debug_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 70 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::data, V24Command::dataLength, DBG, lg, V24Control::parseFloatData(), V24Control::receiveCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_GET_DEBUG und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00070 { 00071 00072 V24COMMAND c, d; 00073 QString output; 00074 unsigned char randomNumbers[10]; 00075 //unsigned char* bytes; 00076 00077 this->lg->v24Data->setText("performing debug function..."); 00078 00079 c.command = V24_COMMAND_GET_DEBUG; 00080 c.dataLength = 0x00; 00081 00082 if (!v24->transmitCommand(&c)) { 00083 v24->closeDevice(); 00084 this->lg->v24Data->setText("!!transmit error!!"); 00085 return; 00086 } 00087 00088 if (!v24->receiveCommand(&d)) { 00089 DBG(); 00090 v24->closeDevice(); 00091 this->lg->v24Data->setText("!!receive error!!"); 00092 return; 00093 } 00094 00095 for (int i=4; i<d.dataLength; i++) { 00096 randomNumbers[i] = d.data[i]; 00097 } 00098 00099 float _expProbability; 00100 v24->parseFloatData(&d.data[0], (float*)&_expProbability); 00101 00102 this->lg->v24Data->setText( "eta=" + QString::number (_expProbability) + ", Random actions: " + 00103 QString::number (randomNumbers[4]) + ", " + 00104 QString::number (randomNumbers[5]) + ", " + 00105 QString::number (randomNumbers[6]) + ", " + 00106 QString::number (randomNumbers[7]) + ", " + 00107 QString::number (randomNumbers[8]) + ", " + 00108 QString::number (randomNumbers[9])); 00109 00110 }
void LaufroboterDialog::v24_distance_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 256 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::data, V24Command::dataLength, DBG, lg, V24Control::parseIntegerData(), V24Control::receiveCommand(), V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_GET_DISTANCE und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00256 { 00257 00258 V24COMMAND c, d; 00259 QString output; 00260 signed int _distance=5; 00261 //unsigned char* bytes; 00262 00263 this->lg->v24Data->setText("reading distance traveled..."); 00264 00265 c.command = V24_COMMAND_GET_DISTANCE; 00266 c.dataLength = 0x00; 00267 00268 if (!v24->transmitCommand(&c)) { 00269 v24->closeDevice(); 00270 this->lg->v24Data->setText("!!transmit error!!"); 00271 return; 00272 } 00273 00274 00275 if (!v24->receiveCommand(&d)) { 00276 DBG(); 00277 v24->closeDevice(); 00278 this->lg->v24Data->setText("!!receive error!!"); 00279 return; 00280 } 00281 00282 // IterationCount auslesen 00283 v24->parseIntegerData(&d.data[0], (unsigned int*)&_distance); 00284 00285 output = QString("distance covered: " + QString::number(_distance)); 00286 00287 this->lg->v24Data->setText(output); 00288 00289 // Okey abwarten, bis nächstes Kommando gesendet werden kann 00290 v24->receiveTransmitOKCommand(); 00291 v24->closeDevice(); 00292 }
void LaufroboterDialog::v24_exploration_accept_clicked | ( | ) | [private, slot] |
Definiert in Zeile 174 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::data, V24Command::dataLength, expMode, expParameter, lg, V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_SET_EXPLORATION_CONFIG, V24_EXP_MODE_EGREEDY, V24_EXP_MODE_VALUE_BASED, LaufroboterMainWindow::v24Data, LaufroboterMainWindow::v24ExplorationModeEGreedy, LaufroboterMainWindow::v24ExplorationModeValueBased und LaufroboterMainWindow::v24ExplorationParameterInput.
Wird benutzt von LaufroboterDialog().
00174 { 00175 00176 V24COMMAND c; 00177 unsigned char* _bytes; 00178 00179 this->lg->v24Data->setText("new expParameter set to " + this->lg->v24ExplorationParameterInput->text()); 00180 00181 // String nach Float konvertieren 00182 this->expParameter = this->lg->v24ExplorationParameterInput->text().toDouble(); 00183 if (this->lg->v24ExplorationModeEGreedy->isOn()) { 00184 this->expMode = V24_EXP_MODE_EGREEDY; 00185 } else if (this->lg->v24ExplorationModeValueBased->isOn()) { 00186 this->expMode = V24_EXP_MODE_VALUE_BASED; 00187 } 00188 00189 printf ("Exploration Mode %d, Parameter: %f\n", this->expMode, this->expParameter); 00190 00191 00192 /**************************** 00193 * expBeta schicken * 00194 ****************************/ 00195 c.command = V24_COMMAND_SET_EXPLORATION_CONFIG; 00196 c.dataLength = sizeof(this->expParameter)+1; 00197 _bytes = (unsigned char*) &expParameter; 00198 for (int i=0; i < c.dataLength-1; i++) { 00199 c.data[i] = _bytes[i]; 00200 } 00201 c.data[c.dataLength-1] = expMode; 00202 00203 00204 // Befehl schicken um expBeta zu setzen 00205 if (!v24->transmitCommand(&c)) { 00206 v24->closeDevice(); 00207 this->lg->v24Data->setText("!!transmit error!!"); 00208 return; 00209 } 00210 00211 v24->receiveTransmitOKCommand(); 00212 v24->closeDevice(); 00213 }
void LaufroboterDialog::v24_exploration_mode_changed | ( | ) | [private, slot] |
Definiert in Zeile 57 der Datei gui_v24.cpp.
Benutzt lg, LaufroboterMainWindow::v24ExplorationLabel, LaufroboterMainWindow::v24ExplorationModeEGreedy und LaufroboterMainWindow::v24ExplorationModeValueBased.
Wird benutzt von LaufroboterDialog() und v24_get_exploration_clicked().
00057 { 00058 00059 if (this->lg->v24ExplorationModeEGreedy->isChecked()) { 00060 this->lg->v24ExplorationLabel->setText("<b>exploration/exploitation parameter (epsilon):</b>"); 00061 } 00062 else if (this->lg->v24ExplorationModeValueBased->isChecked()) { 00063 this->lg->v24ExplorationLabel->setText("<b>exploration/exploitation parameter (sigma):</b>"); 00064 } 00065 }
void LaufroboterDialog::v24_explore_feedback_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 525 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::dataLength, lg, V24Control::openDevice(), V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_EXPLORE_FEEDBACK und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00525 { 00526 00527 V24COMMAND c; 00528 00529 v24->openDevice(); 00530 00531 this->lg->v24Data->setText("exploring environment..."); 00532 00533 // Kommando schicken 00534 c.command = V24_COMMAND_EXPLORE_FEEDBACK; 00535 c.dataLength = 0x00; 00536 if (!v24->transmitCommand(&c)) { 00537 v24->closeDevice(); 00538 this->lg->v24Data->setText("!!transmit error!!"); 00539 return; 00540 } 00541 00542 // Okey abwarten, bis nächstes Kommando gesendet werden kann 00543 v24->receiveTransmitOKCommand(); 00544 00545 // Schnittstelle schließen 00546 v24->closeDevice(); 00547 }
void LaufroboterDialog::v24_get_exploration_clicked | ( | ) | [private, slot] |
Definiert in Zeile 115 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::data, V24Command::dataLength, DBG, expMode, expParameter, lg, V24Control::parseFloatData(), V24Control::receiveCommand(), V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_GET_EXPLORATION_CONFIG, v24_exploration_mode_changed(), LaufroboterMainWindow::v24Data, LaufroboterMainWindow::v24ExplorationModeEGreedy, LaufroboterMainWindow::v24ExplorationModeValueBased und LaufroboterMainWindow::v24ExplorationParameterInput.
Wird benutzt von LaufroboterDialog().
00115 { 00116 00117 V24COMMAND c, d; 00118 QString output; 00119 float _expParameter; 00120 unsigned char _expMode; 00121 //unsigned char* bytes; 00122 00123 this->lg->v24Data->setText("reading exploration config..."); 00124 00125 c.command = V24_COMMAND_GET_EXPLORATION_CONFIG; 00126 c.dataLength = 0x00; 00127 00128 if (!v24->transmitCommand(&c)) { 00129 v24->closeDevice(); 00130 this->lg->v24Data->setText("!!transmit error!!"); 00131 return; 00132 } 00133 00134 if (!v24->receiveCommand(&d)) { 00135 DBG(); 00136 v24->closeDevice(); 00137 this->lg->v24Data->setText("!!receive error!!"); 00138 return; 00139 } 00140 00141 // deserialize data 00142 v24->parseFloatData(&d.data[0], (float*)&_expParameter); 00143 _expMode = d.data[4]; 00144 00145 // set proper variables 00146 this->expMode = _expMode; 00147 if (this->expMode == 0) { 00148 this->lg->v24ExplorationModeEGreedy->setChecked(true); 00149 this->lg->v24ExplorationModeValueBased->setChecked(false); 00150 } 00151 if (this->expMode == 1) { 00152 this->lg->v24ExplorationModeEGreedy->setChecked(false); 00153 this->lg->v24ExplorationModeValueBased->setChecked(true); 00154 } 00155 this->v24_exploration_mode_changed(); 00156 00157 this->expParameter = _expParameter; 00158 this->lg->v24ExplorationParameterInput->setText(QString::number(this->expParameter)); 00159 00160 00161 // debug output 00162 output = QString("mode: " + QString::number(_expMode) + ", parameter: " + QString::number(_expParameter)); 00163 this->lg->v24Data->setText(output); 00164 00165 // send ok 00166 v24->receiveTransmitOKCommand(); 00167 v24->closeDevice(); 00168 }
void LaufroboterDialog::v24_get_states_and_gamma_from_robot_button_clicked | ( | ) | [private, slot] |
Diese Funktion, liefert den gesamten Zustandsraum * und das Gamma vom Laufroboter.
Definiert in Zeile 664 der Datei gui_v24.cpp.
Benutzt apply_button_clicked(), V24Control::closeDevice(), V24Command::command, dad, V24Command::data, V24Command::dataLength, DBG, State::feedback_down, State::feedback_left, State::feedback_right, State::feedback_up, guiReady, lg, NOTHING, LaufroboterMainWindow::numCols, LaufroboterMainWindow::numRows, V24Control::parseFloatData(), pkt, V24Control::receiveCommand(), V24Control::receiveTransmitOKCommand(), scalX, scalY, ValueIterationThread::setFeedback(), ValueIterationThread::setModusFromExtern(), ValueIterationThread::setViValue(), STATESIZE, stopLearningThread(), LaufroboterMainWindow::strategyTable, V24Control::transmitCommand(), ValueIterationThread::unlockMutex(), updateFeedbackTable(), updatePolicyTable(), v24, V24_COMMAND_GET_ALL_STATES_AND_GAMMA, V24_COMMAND_GET_GAMMA, V24_COMMAND_GET_GRIDSIZE, V24_COMMAND_GET_STATE, LaufroboterMainWindow::v24Data, State::value, LaufroboterMainWindow::viGammaInput und LaufroboterMainWindow::viValueTable.
Wird benutzt von LaufroboterDialog().
00664 { 00665 00666 V24COMMAND c, d; 00667 STATE _state; 00668 float _gamma; 00669 unsigned char* _bytes = (unsigned char*) &_state; 00670 int _scalX, _scalY; 00671 00672 // neuen KI Thread erzeugen, falls noch keiner existiert 00673 if (this->pkt != NULL) { 00674 this->apply_button_clicked(); 00675 } 00676 00677 this->stopLearningThread(); 00678 00679 /******************************************************* 00680 * Kommando schicken, dass nun eine Bulk-Anfrage kommt * 00681 *******************************************************/ 00682 c.command = V24_COMMAND_GET_ALL_STATES_AND_GAMMA; 00683 c.dataLength = 0x00; 00684 00685 // Befehl schicken 00686 if (!v24->transmitCommand(&c)) { 00687 this->lg->v24Data->setText("!!transmit error!!"); 00688 DBG(); 00689 v24->closeDevice(); 00690 return; 00691 } 00692 00693 /************************************************** 00694 * Befehl schicken um Gamma auszulesen * 00695 **************************************************/ 00696 c.command = V24_COMMAND_GET_GAMMA; 00697 c.dataLength = 0x00; 00698 00699 // senden 00700 if (!v24->transmitCommand(&c)) { 00701 this->lg->v24Data->setText("!!transmit error!!"); 00702 DBG(); 00703 v24->closeDevice(); 00704 return; 00705 } 00706 00707 // Gamma empfangen 00708 if (!v24->receiveCommand(&d)) { 00709 this->lg->v24Data->setText("!!receive error!!"); 00710 DBG(); 00711 v24->closeDevice(); 00712 return; 00713 } 00714 v24->parseFloatData(&d.data[0], &_gamma); 00715 00716 // Gamma im Textfeld ausgeben 00717 this->lg->viGammaInput->setText(QString::number(_gamma)); 00718 00719 // noch kurz warten bis das OK kommt, dass der Befehl abgearbeitet wurde 00720 if (!v24->receiveTransmitOKCommand()) { 00721 this->lg->v24Data->setText("!!receive error!!"); 00722 DBG(); 00723 v24->closeDevice(); 00724 return; 00725 } 00726 00727 00728 /************************************************** 00729 * Aktuelle Grid Größe auslesen * 00730 **************************************************/ 00731 c.command = V24_COMMAND_GET_GRIDSIZE; 00732 c.dataLength = 0x00; 00733 00734 // Befehl schicken auf Leitung 00735 if (!v24->transmitCommand(&c)) { 00736 this->lg->v24Data->setText("!!transmit error!!"); 00737 DBG(); 00738 v24->closeDevice(); 00739 return; 00740 } 00741 00742 // Grid-Größe empfangen 00743 if (!v24->receiveCommand(&d)) { 00744 this->lg->v24Data->setText("!!receive error!!"); 00745 DBG(); 00746 v24->closeDevice(); 00747 return; 00748 } 00749 00750 // OK-Kommando empfangen 00751 if (!v24->receiveTransmitOKCommand()) { 00752 this->lg->v24Data->setText("!!receive error!!"); 00753 DBG(); 00754 v24->closeDevice(); 00755 return; 00756 } 00757 00758 _scalY = scalY = d.data[0]; 00759 _scalX = scalX = d.data[1]; 00760 00761 this->lg->numCols->setValue(_scalX); 00762 this->scalX = _scalX; 00763 this->lg->numRows->setValue(_scalY); 00764 this->scalY = _scalY; 00765 00766 00767 /******************************************************* 00768 * GUI neu konfigurieren, mit den aktuellen Parametern * 00769 *******************************************************/ 00770 this->guiReady = false; 00771 this->apply_button_clicked(); 00772 00773 // KI-Thread anhalten 00774 this->pkt->setModusFromExtern('q'); 00775 while (this->pkt->running()) { 00776 this->pkt->unlockMutex(); 00777 } 00778 00779 00780 /************************************************** 00781 * Zustände auslesen * 00782 **************************************************/ 00783 for (int _row=0; _row<scalY; _row++) { 00784 for (int _column=0; _column<scalX; _column++) { 00785 00786 // Anforderung schicken 00787 c.command = V24_COMMAND_GET_STATE; 00788 c.dataLength = 0x02; 00789 c.data[0] = (unsigned char)_row; 00790 c.data[1] = (unsigned char)_column; 00791 00792 // Befehl schicken 00793 if (!v24->transmitCommand(&c)) { 00794 this->lg->v24Data->setText("!!transmit error!!"); 00795 DBG(); 00796 v24->closeDevice(); 00797 return; 00798 } 00799 00800 // Zustand empfangen 00801 if (!v24->receiveCommand(&d)) { 00802 this->lg->v24Data->setText("!!receive error!!"); 00803 DBG(); 00804 v24->closeDevice(); 00805 return; 00806 } 00807 00808 // noch kurz warten bis das OK kommt, dass der Befehl abgearbeitet wurde 00809 if (!v24->receiveTransmitOKCommand()) { 00810 this->lg->v24Data->setText("!!receive error!!"); 00811 v24->closeDevice(); 00812 return; 00813 } 00814 00815 for (uint i=0; i<STATESIZE; i++) { 00816 // Kopiere die empfangenen Daten nach (STATE)_state 00817 _bytes[i] = d.data[2+i]; 00818 } 00819 00820 // Value in GUI und VI-Thread speichern 00821 //while (this->pkt->running()); 00822 this->updatePolicyTable ( _row, _column, (double)_state.value, NOTHING); 00823 this->pkt->setViValue( _row, _column, _state.value ); 00824 00825 // Feedback in GUI und VI-Thread speichern 00826 this->updateFeedbackTable(_row, _column, _state.feedback_up, 00827 _state.feedback_down, 00828 _state.feedback_left, 00829 _state.feedback_right ); 00830 this->pkt->setFeedback( _row, _column, _state.feedback_up, 00831 _state.feedback_down, 00832 _state.feedback_left, 00833 _state.feedback_right ); 00834 00835 // Value- und Policy-Table Zelle updaten 00836 lg->viValueTable->updateCell(_row, _column); 00837 lg->strategyTable->updateCell(_row, _column); 00838 } 00839 } 00840 00841 // noch kurz warten bis das OK kommt, dass der Befehl abgearbeitet wurde 00842 /*if (!v24->receiveTransmitOKCommand()) { 00843 v24->closeDevice(); 00844 return; 00845 }*/ 00846 00847 // Value- und Policy Tabelle resizen 00848 this->dad->lock(); 00849 for (int i=0; i < this->scalX; i++) { 00850 lg->viValueTable->adjustColumn (i); 00851 lg->strategyTable->adjustColumn (i); 00852 } 00853 this->dad->unlock(); 00854 00855 // Text-Label aktualisieren 00856 this->lg->v24Data->setText("grid size: " + QString::number(scalY) + "x" + QString::number(scalX) + 00857 ", Gamma: " + QString::number(_gamma)); 00858 00859 // Schnittstelle öffnen 00860 v24->closeDevice(); 00861 }
void LaufroboterDialog::v24_getPositionAndMode_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 476 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::data, V24Command::dataLength, DBG, lg, V24Control::openDevice(), V24Control::parseIntegerData(), V24Control::receiveCommand(), V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_GET_CURRENTPOSITION_AND_MODE, LaufroboterMainWindow::v24Data und v24Modes.
Wird benutzt von LaufroboterDialog().
00476 { 00477 00478 V24COMMAND c, d; 00479 QString output; 00480 unsigned int _itCount=5; 00481 //unsigned char* bytes; 00482 00483 this->lg->v24Data->setText("reading position..."); 00484 00485 v24->openDevice(); 00486 00487 // Kommando schicken 00488 c.command = V24_COMMAND_GET_CURRENTPOSITION_AND_MODE; 00489 c.dataLength = 0x00; 00490 00491 if (!v24->transmitCommand(&c)) { 00492 DBG(); 00493 v24->closeDevice(); 00494 this->lg->v24Data->setText("!!receive error!!"); 00495 return; 00496 } 00497 00498 if (!v24->receiveCommand(&d)) { 00499 DBG(); 00500 v24->closeDevice(); 00501 this->lg->v24Data->setText("!!receive error!!"); 00502 return; 00503 } 00504 00505 // IterationCount auslesen 00506 v24->parseIntegerData(&d.data[3], &_itCount); 00507 00508 output = QString("Y=" + QString::number (d.data[0]+1) + 00509 ", X=" + QString::number (d.data[1]+1) + 00510 ", Mode: " + v24Modes[d.data[2]] + 00511 ", Iteration#: " + QString::number(_itCount)); 00512 00513 this->lg->v24Data->setText(output); 00514 00515 // Okey abwarten, bis nächstes Kommando gesendet werden kann 00516 v24->receiveTransmitOKCommand(); 00517 00518 // Schnittstelle schließen 00519 v24->closeDevice(); 00520 }
void LaufroboterDialog::v24_ramtest_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 552 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::data, V24Command::dataLength, DBG, lg, RAMSIZE, V24Control::receiveCommand(), V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_READ_RAM_BYTES, V24_COMMAND_WRITE_RAM_BYTES und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00552 { 00553 00554 // RAM Test 00555 #define RAMSIZE ((9*200)/16)*16 00556 //#define RAMSIZE 16 00557 unsigned char ramArrayLocal[RAMSIZE], ramArrayRemote[RAMSIZE]; 00558 00559 // Zufallszahlengenerator initialisieren 00560 srand( (unsigned int) time(NULL)); 00561 00562 V24COMMAND c, d; 00563 00564 this->lg->v24Data->setText("initializing..."); 00565 // Arrays Initialisieren 00566 for (int i=0; i<RAMSIZE; i++) { 00567 ramArrayLocal[i] = (rand() %255)+1; 00568 ramArrayRemote[i] = 0x00; 00569 } 00570 00571 // Array mit Zufallszahlen befüllen 00572 //V24_COMMAND_WRITE_RAM_BYTE 00573 //V24_COMMAND_READ_RAM_BYTE 00574 00575 00576 this->lg->v24Data->setText("writing random data to RAM..."); 00577 c.command = V24_COMMAND_WRITE_RAM_BYTES; 00578 c.dataLength = 0x12; 00579 // ein paar Bytes schreiben ... 00580 for (int i=0; i<RAMSIZE; i+=16) { 00581 00582 // Zelle beschreiben 00583 // => Adresse 00584 c.data[0] = i/256; // Highbyte 00585 c.data[1] = i%256; // Lowbyte 00586 00587 for (int j=0; j<16; j++) { 00588 c.data[2+j] = ramArrayLocal[i+j]; 00589 } 00590 00591 // Kommando senden 00592 if (!v24->transmitCommand(&c)) { 00593 this->lg->v24Data->setText("!!transmit error!!"); 00594 v24->closeDevice(); 00595 return; 00596 } 00597 00598 // OK empfangen 00599 if (!v24->receiveTransmitOKCommand()) { 00600 this->lg->v24Data->setText("!!receive error!!"); 00601 v24->closeDevice(); 00602 return; 00603 } 00604 00605 printf ("written data=%d to addr=%d\n", ramArrayLocal[i], i); 00606 } 00607 00608 // und überprüfen, ob alles richtig im RAM liegt 00609 this->lg->v24Data->setText("reading data from RAM..."); 00610 c.command = V24_COMMAND_READ_RAM_BYTES; 00611 c.dataLength = 0x03; 00612 for (int i=0; i<RAMSIZE; i=i+16) { 00613 00614 // => Adresse 00615 c.data[0] = i/256; // Highbyte 00616 c.data[1] = i%256; // Lowbyte 00617 c.data[2] = 16; // Anzahl der Datenbytes 00618 00619 // Kommando senden 00620 if (!v24->transmitCommand(&c)) { 00621 this->lg->v24Data->setText("!!transmit error!!"); 00622 v24->closeDevice(); 00623 return; 00624 } 00625 00626 // Antwort empfangen 00627 DBG(); 00628 v24->receiveCommand(&d); 00629 DBG(); 00630 for (int j=0; j<16; j++) { 00631 ramArrayRemote[i+j] = d.data[2+j]; 00632 } 00633 00634 // OK empfangen 00635 if (!v24->receiveTransmitOKCommand()) { 00636 this->lg->v24Data->setText("!!receive error!!"); 00637 v24->closeDevice(); 00638 return; 00639 } 00640 00641 // Überprüfen, ob beide Werte übereinstimmen 00642 for (int j=0; j<16; j++) { 00643 if (ramArrayLocal[i+j] != ramArrayRemote[i+j]) { 00644 printf ("ERROR: ramArrayLocal[%d]=%d != ramArrayRemote[%d]=%d\n", 00645 i+j, ramArrayLocal[i+j], i+j, ramArrayRemote[i+j]); 00646 this->lg->v24Data->setText("ERROR: RAM test failed..."); 00647 return; 00648 } else { 00649 printf ("OK: data=%d from addr=%d, matches local data\n", ramArrayLocal[i+j], i+j); 00650 } 00651 } 00652 } 00653 00654 00655 // Schnittstelle wieder schließen 00656 v24->closeDevice(); 00657 this->lg->v24Data->setText("RAM test OK..."); 00658 }
void LaufroboterDialog::v24_reset_distance_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 297 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::dataLength, lg, V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_RESET_DISTANCE_COUNTER und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00297 { 00298 00299 V24COMMAND c; 00300 00301 this->lg->v24Data->setText("distance cleared..."); 00302 00303 // Laufkommando schicken 00304 c.command = V24_COMMAND_RESET_DISTANCE_COUNTER; 00305 c.dataLength = 0; 00306 00307 if (!v24->transmitCommand(&c)) { 00308 v24->closeDevice(); 00309 this->lg->v24Data->setText("!!transmit error!!"); 00310 return; 00311 } 00312 00313 v24->receiveTransmitOKCommand(); 00314 v24->closeDevice(); 00315 00316 }
void LaufroboterDialog::v24_start_learning_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 32 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::dataLength, lg, V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_START_LEARNING und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00032 { 00033 00034 V24COMMAND c; 00035 00036 this->lg->v24Data->setText("learning..."); 00037 00038 // Laufkommando schicken 00039 c.command = V24_COMMAND_START_LEARNING; 00040 c.dataLength = 0; 00041 00042 if (!v24->transmitCommand(&c)) { 00043 v24->closeDevice(); 00044 this->lg->v24Data->setText("!!transmit error!!"); 00045 return; 00046 } 00047 00048 v24->receiveTransmitOKCommand(); 00049 v24->closeDevice(); 00050 00051 //} 00052 }
void LaufroboterDialog::v24_start_walking_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 7 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::dataLength, lg, V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_START_WALKING und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00007 { 00008 00009 V24COMMAND c; 00010 00011 this->lg->v24Data->setText("walking..."); 00012 00013 // Laufkommando schicken 00014 c.command = V24_COMMAND_START_WALKING; 00015 c.dataLength = 0; 00016 00017 if (!v24->transmitCommand(&c)) { 00018 v24->closeDevice(); 00019 this->lg->v24Data->setText("!!transmit error!!"); 00020 return; 00021 } 00022 00023 v24->receiveTransmitOKCommand(); 00024 v24->closeDevice(); 00025 00026 //} 00027 }
void LaufroboterDialog::v24_stop_walking_button_clicked | ( | ) | [private, slot] |
Definiert in Zeile 321 der Datei gui_v24.cpp.
Benutzt V24Control::closeDevice(), V24Command::command, V24Command::dataLength, lg, V24Control::receiveTransmitOKCommand(), V24Control::transmitCommand(), v24, V24_COMMAND_STOP_WALKING und LaufroboterMainWindow::v24Data.
Wird benutzt von LaufroboterDialog().
00321 { 00322 00323 //for (int i=0; i<100; i++) { 00324 this->lg->v24Data->setText("stopped."); 00325 00326 V24COMMAND c; 00327 00328 // LED ausschalten 00329 //c.command = V24_COMMAND_LED_OFF; 00330 //c.dataLength = 0; 00331 00332 // LED Kommando schicken 00333 //v24->transmitCommand(&c); 00334 //v24->receiveTransmitOKCommand(); 00335 00336 // Laufkommando schicken 00337 c.command = V24_COMMAND_STOP_WALKING; 00338 c.dataLength = 0; 00339 00340 if (!v24->transmitCommand(&c)) { 00341 v24->closeDevice(); 00342 this->lg->v24Data->setText("!!transmit error!!"); 00343 return; 00344 } 00345 00346 v24->receiveTransmitOKCommand(); 00347 00348 // Schnittstelle wieder schließen 00349 v24->closeDevice(); 00350 //} 00351 }
void LaufroboterDialog::vi_train_random_values_changed | ( | int | _value | ) | [private, slot] |
_value |
Definiert in Zeile 157 der Datei gui_simu_val_pol.cpp.
Benutzt debugOutput(), lg, pkt, scalX, scalY, ValueIterationThread::setTrainRandomValues(), LaufroboterMainWindow::viRandomNetSliderText und LaufroboterMainWindow::viRandomValuesSlider.
Wird benutzt von apply_button_clicked().
00157 { 00158 00159 int _percVal = (int)((100.0 * (float)_value) / (float)this->lg->viRandomValuesSlider->maxValue()); 00160 int _valCount = (int)((float)scalX * (float)scalY * ((float)_percVal/100.0)); 00161 00162 // Neue Anzahl setzen, wieviel Prozent der Values trainiert werden 00163 if (this->pkt != NULL) { 00164 this->pkt->setTrainRandomValues(_valCount); 00165 } 00166 00167 debugOutput ("GUI: training " + QString::number(_percVal) + "% (" + QString::number(_valCount) + ") random values to net"); 00168 this->lg->viRandomNetSliderText->setText("training " + QString::number(_percVal) + "% (" + QString::number(_valCount) + " random) values to net:"); 00169 }
QWidget* LaufroboterDialog::_widget [private] |
int LaufroboterDialog::action[YMAX][XMAX] [private] |
QApplication* LaufroboterDialog::dad [private] |
Definiert in Zeile 75 der Datei gui.h.
Wird benutzt von LaufroboterDialog(), updateFeedbackTable(), updatePolicyTable() und v24_get_states_and_gamma_from_robot_button_clicked().
QMutex* LaufroboterDialog::debugMutex [private] |
Definiert in Zeile 69 der Datei gui.h.
Wird benutzt von v24_exploration_accept_clicked() und v24_get_exploration_clicked().
Definiert in Zeile 68 der Datei gui.h.
Wird benutzt von v24_exploration_accept_clicked() und v24_get_exploration_clicked().
double LaufroboterDialog::feedbackMemory[YMAX][XMAX][5] [private] |
Definiert in Zeile 84 der Datei gui.h.
Wird benutzt von getReward(), load_button_clicked(), save_feedback_clicked() und setReward().
float LaufroboterDialog::fValueMemory[YMAX][XMAX] [private] |
Definiert in Zeile 85 der Datei gui.h.
Wird benutzt von updatePolicyTable() und v24_copy_states_and_gamma_to_robot_button_clicked().
float LaufroboterDialog::gamma |
Definiert in Zeile 67 der Datei gui.h.
Wird benutzt von apply_button_clicked() und v24_copy_states_and_gamma_to_robot_button_clicked().
QMutex* LaufroboterDialog::guiMutex [private] |
Definiert in Zeile 80 der Datei gui.h.
Wird benutzt von delete_button_clicked(), iteration_button_clicked(), LaufroboterDialog(), learn_button_clicked(), learn_method_nn_clicked(), learn_method_vi_clicked(), learn_method_vi_nn_clicked() und stop_button_clicked().
bool LaufroboterDialog::guiReady [private] |
Definiert in Zeile 81 der Datei gui.h.
Wird benutzt von apply_button_clicked() und v24_get_states_and_gamma_from_robot_button_clicked().
int LaufroboterDialog::i_cell [private] |
Definiert in Zeile 82 der Datei gui.h.
Wird benutzt von apply_button_clicked(), updateFeedbackTable() und updatePolicyTable().
int LaufroboterDialog::i_update [private] |
int LaufroboterDialog::iMantisse [private] |
Definiert in Zeile 83 der Datei gui.h.
Wird benutzt von apply_button_clicked(), LaufroboterDialog() und updatePolicyTable().
Definiert in Zeile 60 der Datei gui.h.
Wird benutzt von adjust_network_error(), apply_button_clicked(), debugOutput(), delete_button_clicked(), feedbackClicked(), iteration_button_clicked(), LaufroboterDialog(), learn_button_clicked(), learn_method_nn_clicked(), learn_method_vi_clicked(), learn_method_vi_nn_clicked(), load_button_clicked(), resume_simulation_clicked(), save_button_clicked(), save_feedback_clicked(), save_matlab_button_clicked(), simulationWalk(), speed_slider_changed(), start_simulation_clicked(), stop_button_clicked(), stop_simulation_clicked(), updateFeedbackTable(), updatePolicyTable(), v24_accept_button_clicked(), v24_copy_states_and_gamma_to_robot_button_clicked(), v24_debug_button_clicked(), v24_distance_button_clicked(), v24_exploration_accept_clicked(), v24_exploration_mode_changed(), v24_explore_feedback_button_clicked(), v24_get_exploration_clicked(), v24_get_states_and_gamma_from_robot_button_clicked(), v24_getPositionAndMode_button_clicked(), v24_ramtest_button_clicked(), v24_reset_distance_button_clicked(), v24_start_learning_button_clicked(), v24_start_walking_button_clicked(), v24_stop_walking_button_clicked() und vi_train_random_values_changed().
QPixmap LaufroboterDialog::pix[6] [private] |
Definiert in Zeile 76 der Datei gui.h.
Wird benutzt von apply_button_clicked(), LaufroboterDialog() und updatePolicyTable().
Definiert in Zeile 61 der Datei gui.h.
Wird benutzt von apply_button_clicked(), delete_button_clicked(), iteration_button_clicked(), LaufroboterDialog(), learn_button_clicked(), learn_method_nn_clicked(), learn_method_vi_clicked(), learn_method_vi_nn_clicked(), load_button_clicked(), save_feedback_clicked(), speed_slider_changed(), stopLearningThread(), updateFeedbackTable(), updatePolicyTable(), v24_get_states_and_gamma_from_robot_button_clicked(), vi_train_random_values_changed() und ~LaufroboterDialog().
uchar LaufroboterDialog::scalX |
Definiert in Zeile 70 der Datei gui.h.
Wird benutzt von apply_button_clicked(), v24_copy_states_and_gamma_to_robot_button_clicked(), v24_get_states_and_gamma_from_robot_button_clicked() und vi_train_random_values_changed().
uchar LaufroboterDialog::scalY |
Definiert in Zeile 70 der Datei gui.h.
Wird benutzt von apply_button_clicked(), v24_copy_states_and_gamma_to_robot_button_clicked(), v24_get_states_and_gamma_from_robot_button_clicked() und vi_train_random_values_changed().
Definiert in Zeile 64 der Datei gui.h.
Wird benutzt von apply_button_clicked(), LaufroboterDialog(), resume_simulation_clicked(), simulationWalk(), start_simulation_clicked() und stop_simulation_clicked().
QDialog* LaufroboterDialog::simuDialog [private] |
QPoint LaufroboterDialog::simuPos [private] |
Definiert in Zeile 87 der Datei gui.h.
Wird benutzt von LaufroboterDialog(), simulationWalk() und start_simulation_clicked().
QPoint LaufroboterDialog::simuPosNew [private] |
int LaufroboterDialog::speed [private] |
Definiert in Zeile 74 der Datei gui.h.
Wird benutzt von apply_button_clicked(), learn_button_clicked() und speed_slider_changed().
QTimer* LaufroboterDialog::st |
Definiert in Zeile 62 der Datei gui.h.
Wird benutzt von LaufroboterDialog(), resume_simulation_clicked(), simulationWalk(), start_simulation_clicked() und stop_simulation_clicked().
QMutex* LaufroboterDialog::tableMutex [private] |
Definiert in Zeile 63 der Datei gui.h.
Wird benutzt von LaufroboterDialog(), v24_accept_button_clicked(), v24_copy_states_and_gamma_to_robot_button_clicked(), v24_debug_button_clicked(), v24_distance_button_clicked(), v24_exploration_accept_clicked(), v24_explore_feedback_button_clicked(), v24_get_exploration_clicked(), v24_get_states_and_gamma_from_robot_button_clicked(), v24_getPositionAndMode_button_clicked(), v24_ramtest_button_clicked(), v24_reset_distance_button_clicked(), v24_start_learning_button_clicked(), v24_start_walking_button_clicked() und v24_stop_walking_button_clicked().