Simulation Klassenreferenz

#include <gui.h>

Klassendiagramm für Simulation:

Inheritance graph
[Legende]
Zusammengehörigkeiten von Simulation:

Collaboration graph
[Legende]

Ausführliche Beschreibung

Definiert in Zeile 50 der Datei gui.h.


Öffentliche Methoden

void initDialog ()
 Simulation (QApplication *_mainApp)
 ~Simulation ()

Datenfelder

uchar expMode
float expParameter
float gamma
char ki_in
SimulationMainWindowlg
ValueIterationThreadpkt
uchar scalX
uchar scalY
SimulationDialogsd
QTimer * st
V24Controlv24

Private Slots

void adjust_network_error (double _newError)
void apply_button_clicked ()
void debugOutput (QString _d)
void delete_button_clicked ()
void feedbackClicked (int row, int col)
void iteration_button_clicked ()
void learn_button_clicked ()
void learn_method_nn_clicked ()
void learn_method_vi_clicked ()
void learn_method_vi_nn_clicked ()
void load_button_clicked ()
void resume_simulation_clicked ()
void save_button_clicked ()
void save_feedback_clicked ()
void save_matlab_button_clicked ()
void simulationWalk ()
void speed_slider_changed (int _value)
void start_simulation_clicked ()
void stop_button_clicked ()
void stop_simulation_clicked ()
void stopLearningThread ()
void updateFeedbackTable (int _row, int _column, double _up, double _down, double _left, double _right)
void updatePolicyTable (int _row, int _column, double _value, int _bestdirection)
void v24_accept_button_clicked ()
void v24_copy_states_and_gamma_to_robot_button_clicked ()
void v24_debug_button_clicked ()
void v24_distance_button_clicked ()
void v24_exploration_accept_clicked ()
void v24_exploration_mode_changed ()
void v24_explore_feedback_button_clicked ()
void v24_get_exploration_clicked ()
void v24_get_states_and_gamma_from_robot_button_clicked ()
void v24_getPositionAndMode_button_clicked ()
void v24_ramtest_button_clicked ()
void v24_reset_distance_button_clicked ()
void v24_start_learning_button_clicked ()
void v24_start_walking_button_clicked ()
void v24_stop_walking_button_clicked ()
void vi_train_random_values_changed (int _value)

Private Methoden

double getReward (int x, int y, int action)
void setReward (int x, int y, int action, double reward)

Private Attribute

QWidget * _widget
int action [YMAX][XMAX]
QApplication * dad
QMutex * debugMutex
double feedbackMemory [YMAX][XMAX][5]
float fValueMemory [YMAX][XMAX]
QMutex * guiMutex
bool guiReady
int i_cell
int i_update
int iMantisse
QPixmap pix [6]
QDialogsimuDialog
QPoint simuPos
QPoint simuPosNew
int speed
QMutex * tableMutex

Beschreibung der Konstruktoren und Destruktoren

Simulation::Simulation ( QApplication *  _mainApp  ) 

Konstructor

Parameter:
*_mainApp 

Definiert in Zeile 13 der Datei gui_global.cpp.

Benutzt apply_button_clicked(), SimulationMainWindow::applyButton, SimulationMainWindow::applyButtonVI, dad, DBG, SimulationMainWindow::debugLabel, debugMutex, delete_button_clicked(), SimulationMainWindow::envLoadFileButton, SimulationMainWindow::envSaveFileButton, SimulationMainWindow::envSaveMatlabFileButton, SimulationMainWindow::envSaveRewardButton, guiMutex, i_update, iMantisse, iteration_button_clicked(), learn_button_clicked(), learn_method_nn_clicked(), learn_method_vi_clicked(), lg, load_button_clicked(), SimulationMainWindow::numCols, SimulationMainWindow::numRows, pix, pkt, SimulationMainWindow::QTab, resume_simulation_clicked(), SimulationDialog::resumeSimulationButton, SimulationMainWindow::resumeSimulationButton, save_button_clicked(), save_feedback_clicked(), save_matlab_button_clicked(), sd, simuDialog, simulationWalk(), simuPos, st, start_simulation_clicked(), SimulationDialog::startSimulationButton, SimulationMainWindow::startSimulationButton, stop_button_clicked(), stop_simulation_clicked(), SimulationDialog::stopSimulationButton, SimulationMainWindow::stopSimulationButton, SimulationMainWindow::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(), SimulationMainWindow::v24AcceptButton, SimulationMainWindow::v24CopyStatesAndGammaToRobotButton, SimulationMainWindow::v24DebugButton, SimulationMainWindow::v24ExplorationAcceptButton, SimulationMainWindow::v24ExplorationModeEGreedy, SimulationMainWindow::v24ExplorationModeValueBased, SimulationMainWindow::v24ExploreFeedbackButton, SimulationMainWindow::v24GetDistanceButton, SimulationMainWindow::v24GetExplorationButton, SimulationMainWindow::v24GetPositionAndModeButton, SimulationMainWindow::v24GetStatesAndGammaFromRobotButton, SimulationMainWindow::v24RamtestButton, SimulationMainWindow::v24ResetDistanceButton, SimulationMainWindow::v24StartLearningButton, SimulationMainWindow::v24StartWalkingButton, SimulationMainWindow::v24StopWalkingButton, SimulationMainWindow::viDeleteButton, SimulationMainWindow::viDeleteButton2, SimulationMainWindow::viGammaInput, SimulationMainWindow::viIterationButton, SimulationMainWindow::viIterationButton2, SimulationMainWindow::viLearnWithNN, SimulationMainWindow::viLearnWithVI, SimulationMainWindow::viLernenButton, SimulationMainWindow::viLernenButton2, SimulationMainWindow::viSpeedSlider, SimulationMainWindow::viStopButton, SimulationMainWindow::viStopButton2, SimulationMainWindow::ViTab, SimulationMainWindow::viValueTable, XMAX und YMAX.

00013                                              {
00014 
00015    dad = _mainApp;
00016    
00017    this->lg = new SimulationMainWindow (this);
00018    this->sd = new SimulationDialog();
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 }

Simulation::~Simulation (  ) 

Destructor

Definiert in Zeile 6 der Datei gui_global.cpp.

Benutzt pkt.

00006                         {
00007    delete (this->pkt);
00008 }


Dokumentation der Elementfunktionen

void Simulation::adjust_network_error ( double  _newError  )  [private, slot]

Definiert in Zeile 147 der Datei gui_global.cpp.

Benutzt DBG, lg und SimulationMainWindow::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 Simulation::apply_button_clicked (  )  [private, slot]

Definiert in Zeile 3 der Datei gui_config.cpp.

Benutzt adjust_network_error(), SimulationDialog::canvasView, SimulationMainWindow::canvasView, DBG, debugOutput(), SimulationMainWindow::envLoadFileButton, SimulationMainWindow::envRewardTable, SimulationMainWindow::envSaveFileButton, SimulationMainWindow::envSaveMatlabFileButton, SimulationMainWindow::envSaveRewardButton, feedbackClicked(), gamma, guiReady, i_cell, iMantisse, learn_method_vi_clicked(), lg, SimulationMainWindow::mantisseInput, SimulationMainWindow::netActivationStepnessHidden, SimulationMainWindow::netActivationStepnessOutput, SimulationMainWindow::netAutoAdjustError, SimulationMainWindow::netDesiredError, SimulationMainWindow::netEta, SimulationMainWindow::netHiddenActivationFunction, SimulationMainWindow::netHiddenLayers, SimulationMainWindow::netHiddenUnits, SimulationMainWindow::netIterationsBetweenReport, SimulationMainWindow::netMaxEpochs, SimulationMainWindow::netOutputActivationFunction, SimulationMainWindow::numCols, SimulationMainWindow::numRows, pix, pkt, SimulationMainWindow::QLearningButton, SimulationMainWindow::QTab, scalX, scalY, sd, MyCanvasView::setDimension(), ValueIterationThread::setGamma(), ValueIterationThread::setModusFromExtern(), ValueIterationThread::setNetworkParameters(), ValueIterationThread::setTrainRandomValues(), speed, speed_slider_changed(), SimulationMainWindow::startSimulationButton, SimulationMainWindow::strategyTable, updatePolicyTable(), vi_train_random_values_changed(), SimulationMainWindow::viDeleteButton, SimulationMainWindow::viGammaInput, SimulationMainWindow::viIterationButton, SimulationMainWindow::ViLearningButton, SimulationMainWindow::viLernenButton, SimulationMainWindow::viRandomValuesSlider, SimulationMainWindow::viSpeedSlider, SimulationMainWindow::ViTab und SimulationMainWindow::viValueTable.

Wird benutzt von Simulation() 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 Simulation::debugOutput ( QString  _d  )  [private, slot]

Diese Funktion stellt einen Übergebenen String im Debug-Label dar.

Parameter:
_d String zur Darstellung im Debug-Label

Definiert in Zeile 130 der Datei gui_global.cpp.

Benutzt SimulationMainWindow::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 Simulation::delete_button_clicked (  )  [private, slot]

Definiert in Zeile 105 der Datei gui_simu_val_pol.cpp.

Benutzt DBG, guiMutex, lg, pkt, ValueIterationThread::setModusFromExtern(), stopLearningThread(), SimulationMainWindow::viIterationButton, SimulationMainWindow::viIterationButton2, SimulationMainWindow::viLernenButton, SimulationMainWindow::viLernenButton2, SimulationMainWindow::viStopButton und SimulationMainWindow::viStopButton2.

Wird benutzt von Simulation().

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 Simulation::feedbackClicked ( int  row,
int  col 
) [private, slot]

Funktion wird aufgerufen, wenn auf eine Zelle in der Feedback-Tabelle geklickt wurde

Parameter:
row 
col 

Definiert in Zeile 81 der Datei gui_feedback.cpp.

Benutzt DOWN, SimulationMainWindow::envColLabel, SimulationMainWindow::envDownRewardInput, SimulationMainWindow::envLeftRewardInput, SimulationMainWindow::envRightRewardInput, SimulationMainWindow::envRowLabel, SimulationMainWindow::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 Simulation::getReward ( int  _row,
int  _column,
int  _action 
) [private]

Parameter:
_row 
_column 
_action 
Rückgabe:
double

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 Simulation::initDialog (  ) 

void Simulation::iteration_button_clicked (  )  [private, slot]

Definiert in Zeile 6 der Datei gui_simu_val_pol.cpp.

Benutzt DBG, guiMutex, lg, SimulationMainWindow::netActivationStepnessHidden, SimulationMainWindow::netActivationStepnessOutput, SimulationMainWindow::netAutoAdjustError, SimulationMainWindow::netDesiredError, SimulationMainWindow::netEta, SimulationMainWindow::netHiddenActivationFunction, SimulationMainWindow::netIterationsBetweenReport, SimulationMainWindow::netMaxEpochs, SimulationMainWindow::netOutputActivationFunction, pkt, ValueIterationThread::setModusFromExtern(), ValueIterationThread::setNetworkParameters(), stopLearningThread() und SimulationMainWindow::viLearnWithNN.

Wird benutzt von Simulation().

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 Simulation::learn_button_clicked (  )  [private, slot]

Definiert in Zeile 48 der Datei gui_simu_val_pol.cpp.

Benutzt DBG, guiMutex, lg, SimulationMainWindow::netActivationStepnessHidden, SimulationMainWindow::netActivationStepnessOutput, SimulationMainWindow::netAutoAdjustError, SimulationMainWindow::netDesiredError, SimulationMainWindow::netEta, SimulationMainWindow::netHiddenActivationFunction, SimulationMainWindow::netIterationsBetweenReport, SimulationMainWindow::netMaxEpochs, SimulationMainWindow::netOutputActivationFunction, pkt, ValueIterationThread::setModusFromExtern(), ValueIterationThread::setNetworkParameters(), ValueIterationThread::setSpeed(), speed, stopLearningThread(), SimulationMainWindow::viDeleteButton, SimulationMainWindow::viDeleteButton2, SimulationMainWindow::viIterationButton, SimulationMainWindow::viIterationButton2, SimulationMainWindow::viLearnWithNN, SimulationMainWindow::viLernenButton, SimulationMainWindow::viLernenButton2, SimulationMainWindow::viSpeedSlider, SimulationMainWindow::viStopButton und SimulationMainWindow::viStopButton2.

Wird benutzt von Simulation().

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 Simulation::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(), SimulationMainWindow::viLearnWithNN und SimulationMainWindow::viLearnWithVI.

Wird benutzt von Simulation().

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 Simulation::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(), SimulationMainWindow::viLearnWithNN und SimulationMainWindow::viLearnWithVI.

Wird benutzt von apply_button_clicked() und Simulation().

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 Simulation::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(), SimulationMainWindow::viLearnWithNN und SimulationMainWindow::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 Simulation::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 SimulationMainWindow::debugLabel, DOWN, feedbackMemory, LEFT, lg, SimulationMainWindow::numCols, SimulationMainWindow::numRows, pkt, RIGHT, ValueIterationThread::setFeedback(), UP und updateFeedbackTable().

Wird benutzt von Simulation().

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 Simulation::resume_simulation_clicked (  )  [private, slot]

Definiert in Zeile 45 der Datei gui_simu_simu.cpp.

Benutzt lg, SimulationDialog::resumeSimulationButton, SimulationMainWindow::resumeSimulationButton, sd, st, SimulationDialog::startSimulationButton, SimulationMainWindow::startSimulationButton, SimulationDialog::stopSimulationButton und SimulationMainWindow::stopSimulationButton.

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::debugLabel, DOWN, getReward(), LEFT, lg, SimulationMainWindow::numCols, SimulationMainWindow::numRows, RIGHT und UP.

Wird benutzt von Simulation().

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 Simulation::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, SimulationMainWindow::envDownRewardInput, SimulationMainWindow::envLeftRewardInput, SimulationMainWindow::envRewardTable, SimulationMainWindow::envRightRewardInput, SimulationMainWindow::envUpRewardInput, feedbackMemory, LEFT, lg, pkt, RIGHT, ValueIterationThread::setFeedback(), UP und updateFeedbackTable().

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::debugLabel, DOWN, getReward(), LEFT, lg, SimulationMainWindow::numCols, SimulationMainWindow::numRows, RIGHT und UP.

Wird benutzt von Simulation().

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 Simulation::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

Parameter:
_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 Simulation::simulationWalk (  )  [private, slot]

Definiert in Zeile 74 der Datei gui_simu_simu.cpp.

Benutzt action, SimulationDialog::canvasView, SimulationMainWindow::canvasView, debugOutput(), DOWN, LEFT, lg, MyCanvasView::moveRobot(), RIGHT, sd, simuPos, simuPosNew, st und UP.

Wird benutzt von Simulation().

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 Simulation::speed_slider_changed ( int  _value  )  [private, slot]

Parameter:
_value 

Definiert in Zeile 175 der Datei gui_simu_val_pol.cpp.

Benutzt debugOutput(), lg, pkt, ValueIterationThread::setSpeed(), speed, SimulationMainWindow::viSpeedLabel und SimulationMainWindow::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 Simulation::start_simulation_clicked (  )  [private, slot]

Definiert in Zeile 6 der Datei gui_simu_simu.cpp.

Benutzt SimulationDialog::canvasView, SimulationMainWindow::canvasView, debugOutput(), lg, SimulationMainWindow::numCols, SimulationMainWindow::numRows, SimulationDialog::resumeSimulationButton, SimulationMainWindow::resumeSimulationButton, sd, MyCanvasView::setDimension(), simuPos, st, SimulationDialog::startSimulationButton, SimulationMainWindow::startSimulationButton, SimulationDialog::stopSimulationButton und SimulationMainWindow::stopSimulationButton.

Wird benutzt von Simulation().

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 Simulation::stop_button_clicked (  )  [private, slot]

Definiert in Zeile 131 der Datei gui_simu_val_pol.cpp.

Benutzt DBG, guiMutex, lg, stopLearningThread(), SimulationMainWindow::viDeleteButton, SimulationMainWindow::viDeleteButton2, SimulationMainWindow::viIterationButton, SimulationMainWindow::viIterationButton2, SimulationMainWindow::viLernenButton, SimulationMainWindow::viLernenButton2, SimulationMainWindow::viStopButton und SimulationMainWindow::viStopButton2.

Wird benutzt von Simulation().

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 Simulation::stop_simulation_clicked (  )  [private, slot]

Definiert in Zeile 60 der Datei gui_simu_simu.cpp.

Benutzt debugOutput(), lg, SimulationDialog::resumeSimulationButton, SimulationMainWindow::resumeSimulationButton, sd, st, SimulationDialog::startSimulationButton, SimulationMainWindow::startSimulationButton, SimulationDialog::stopSimulationButton und SimulationMainWindow::stopSimulationButton.

Wird benutzt von Simulation().

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 Simulation::stopLearningThread (  )  [private, slot]

void Simulation::updateFeedbackTable ( int  _row,
int  _column,
double  _up,
double  _down,
double  _left,
double  _right 
) [private, slot]

Funktion zum updaten der Feedback-Tabelle

Parameter:
_row 
_column 
_up 
_down 
_left 
_right 

Definiert in Zeile 37 der Datei gui_feedback.cpp.

Benutzt dad, DOWN, SimulationMainWindow::envRewardTable, getReward(), i_cell, LEFT, lg, SimulationMainWindow::numCols, SimulationMainWindow::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 Simulation::updatePolicyTable ( int  _row,
int  _column,
double  _value,
int  _bestdirection 
) [private, slot]

Parameter:
_row 
_column 
_value 
_bestdirection 

Definiert in Zeile 189 der Datei gui_simu_val_pol.cpp.

Benutzt action, dad, fValueMemory, i_cell, iMantisse, lg, SimulationMainWindow::numCols, pix, pkt, SimulationMainWindow::strategyTable, ValueIterationThread::unlockMutex() und SimulationMainWindow::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 Simulation::v24_accept_button_clicked (  )  [private, slot]

Definiert in Zeile 218 der Datei gui_v24.cpp.

Benutzt lg, V24Control::setInterface(), v24, SimulationMainWindow::v24CopyStatesAndGammaToRobotButton, SimulationMainWindow::v24DebugButton, SimulationMainWindow::v24ExplorationAcceptButton, SimulationMainWindow::v24ExplorationParameterInput, SimulationMainWindow::v24ExploreFeedbackButton, SimulationMainWindow::v24GetDistanceButton, SimulationMainWindow::v24GetExplorationButton, SimulationMainWindow::v24GetPositionAndModeButton, SimulationMainWindow::v24GetStatesAndGammaFromRobotButton, SimulationMainWindow::v24RamtestButton, SimulationMainWindow::v24ResetDistanceButton, SimulationMainWindow::v24StartLearningButton, SimulationMainWindow::v24StartWalkingButton und SimulationMainWindow::v24StopWalkingButton.

Wird benutzt von Simulation().

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 Simulation::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, SimulationMainWindow::v24Data und State::value.

Wird benutzt von Simulation().

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*) &gamma;
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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::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, SimulationMainWindow::v24Data, SimulationMainWindow::v24ExplorationModeEGreedy, SimulationMainWindow::v24ExplorationModeValueBased und SimulationMainWindow::v24ExplorationParameterInput.

Wird benutzt von Simulation().

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 Simulation::v24_exploration_mode_changed (  )  [private, slot]

Definiert in Zeile 57 der Datei gui_v24.cpp.

Benutzt lg, SimulationMainWindow::v24ExplorationLabel, SimulationMainWindow::v24ExplorationModeEGreedy und SimulationMainWindow::v24ExplorationModeValueBased.

Wird benutzt von Simulation() 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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::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(), SimulationMainWindow::v24Data, SimulationMainWindow::v24ExplorationModeEGreedy, SimulationMainWindow::v24ExplorationModeValueBased und SimulationMainWindow::v24ExplorationParameterInput.

Wird benutzt von Simulation().

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 Simulation::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, SimulationMainWindow::numCols, SimulationMainWindow::numRows, V24Control::parseFloatData(), pkt, V24Control::receiveCommand(), V24Control::receiveTransmitOKCommand(), scalX, scalY, ValueIterationThread::setFeedback(), ValueIterationThread::setModusFromExtern(), ValueIterationThread::setViValue(), STATESIZE, stopLearningThread(), SimulationMainWindow::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, SimulationMainWindow::v24Data, State::value, SimulationMainWindow::viGammaInput und SimulationMainWindow::viValueTable.

Wird benutzt von Simulation().

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 Simulation::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, SimulationMainWindow::v24Data und v24Modes.

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::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 SimulationMainWindow::v24Data.

Wird benutzt von Simulation().

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 Simulation::vi_train_random_values_changed ( int  _value  )  [private, slot]

Parameter:
_value 

Definiert in Zeile 157 der Datei gui_simu_val_pol.cpp.

Benutzt debugOutput(), lg, pkt, scalX, scalY, ValueIterationThread::setTrainRandomValues(), SimulationMainWindow::viRandomNetSliderText und SimulationMainWindow::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 }


Dokumentation der Datenelemente

QWidget* Simulation::_widget [private]

Definiert in Zeile 77 der Datei gui.h.

int Simulation::action[YMAX][XMAX] [private]

Definiert in Zeile 86 der Datei gui.h.

Wird benutzt von simulationWalk() und updatePolicyTable().

QApplication* Simulation::dad [private]

QMutex* Simulation::debugMutex [private]

Definiert in Zeile 79 der Datei gui.h.

Wird benutzt von Simulation().

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 Simulation::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 Simulation::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().

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* Simulation::guiMutex [private]

bool Simulation::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 Simulation::i_cell [private]

Definiert in Zeile 82 der Datei gui.h.

Wird benutzt von apply_button_clicked(), updateFeedbackTable() und updatePolicyTable().

int Simulation::i_update [private]

Definiert in Zeile 73 der Datei gui.h.

Wird benutzt von Simulation().

int Simulation::iMantisse [private]

Definiert in Zeile 83 der Datei gui.h.

Wird benutzt von apply_button_clicked(), Simulation() und updatePolicyTable().

Definiert in Zeile 66 der Datei gui.h.

QPixmap Simulation::pix[6] [private]

Definiert in Zeile 76 der Datei gui.h.

Wird benutzt von apply_button_clicked(), Simulation() und updatePolicyTable().

Definiert in Zeile 88 der Datei gui.h.

Wird benutzt von Simulation().

QPoint Simulation::simuPos [private]

Definiert in Zeile 87 der Datei gui.h.

Wird benutzt von Simulation(), simulationWalk() und start_simulation_clicked().

QPoint Simulation::simuPosNew [private]

Definiert in Zeile 87 der Datei gui.h.

Wird benutzt von simulationWalk().

int Simulation::speed [private]

Definiert in Zeile 74 der Datei gui.h.

Wird benutzt von apply_button_clicked(), learn_button_clicked() und speed_slider_changed().

QTimer* Simulation::st

QMutex* Simulation::tableMutex [private]

Definiert in Zeile 78 der Datei gui.h.

Wird benutzt von Simulation().


Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Dateien:

Erzeugt am Mon Nov 24 15:31:04 2008 für Walking Robot Simulation GUI - API Documentation von  doxygen 1.5.5