V24Control Class Reference

#include <V24Control.h>

Collaboration diagram for V24Control:

Collaboration graph
[legend]

Public Member Functions

int getNewMainMode (int oldMainMode)
void init ()
bool newDataReceived ()
void processCommand ()
bool receive (unsigned char *)
void transmit (unsigned char data)
 V24Control ()
 ~V24Control ()

Data Fields

ValueIterationvi

Private Member Functions

void flushReceiveBuffer ()
bool processGetDebug ()
bool processGetExplorationConfig ()
bool processGetGamma ()
bool processGetGridsize ()
bool processGetState (V24COMMAND *cmd)
void processSetGamma (V24COMMAND *cmd)
bool processSetGridsize (V24COMMAND *cmd)
bool processSetMotorPosition (V24Command)
bool processSetState (V24COMMAND *cmd)
bool receiveCommand (V24COMMAND *c)
void setMainMode (int mainMode)
bool transmitCommand (V24COMMAND *c)
bool transmitReceiveCommandProcessed (unsigned char _code, unsigned char _error)

Private Attributes

int mainMode
bool newDataAvailable
int newMainMode
V24COMMAND rx_command
bool rxtx
STATE tmpState
V24COMMAND tx_command

Detailed Description

Controll Class for Serial Interface
Author:
Michel

Definition at line 20 of file V24Control.h.


Constructor & Destructor Documentation

V24Control::V24Control (  ) 

global objects which are used by the interrupt function SIGNAL(SIG_UART_RECV) the constructor. set's the ValueIteration object

Definition at line 13 of file V24Control.c.

References vi.

00013                        {
00014 
00015 
00016 //#ifdef TESTMODE
00017 //#warning VI disabled
00018 //#else   
00019      // create new valueIteration object with a 5x5 StateSpace
00020      this->vi = new ValueIteration(new ENV_POS(5,5));
00021 //#endif
00022 }

V24Control::~V24Control (  ) 

destructor

Definition at line 26 of file V24Control.c.

References vi.

00026                         {
00027      delete this->vi;
00028 }


Member Function Documentation

void V24Control::flushReceiveBuffer (  )  [private]

reset the serial buffer

Definition at line 628 of file V24Control.c.

References BoardController::getSwitchState(), and SWITCH_V24.

Referenced by processCommand().

00628                                     {
00629      if (BoardController::getSwitchState(SWITCH_V24)) {
00630           unsigned char dummy;
00631           while (UCSRA & (1<<RXC)) dummy = UDR;
00632      }
00633 }

Here is the call graph for this function:

int V24Control::getNewMainMode ( int  oldMainMode  ) 

returns a new main mode (if available) and reset's the internal newMainMode variable. If no newMainMode is set, the oldMainMode is returned

Definition at line 867 of file V24Control.c.

References MAIN_MODE_UNCHANGED, and newMainMode.

Referenced by main().

00867                                               {
00868      if (this->newMainMode != MAIN_MODE_UNCHANGED) {
00869           int retMode = this->newMainMode;
00870           this->newMainMode = MAIN_MODE_UNCHANGED;
00871           return retMode;
00872      } else {
00873           return oldMainMode;
00874      }
00875 }

void V24Control::init (  ) 

initializes the serial interface according to baud-rate MYUBRR, 1 stop bit and no parity bit

Definition at line 56 of file V24Control.c.

References BoardController::enableSerialV24Interface(), and rxtx.

00056                        {
00057 
00058      // should each received byte be send back to the sender? (for debug)
00059      rxtx = false;
00060 
00061      // enable serial interface
00062      BoardController::enableSerialV24Interface();
00063 }

Here is the call graph for this function:

bool V24Control::newDataReceived (  ) 

returns true if new data arrived in USART buffer, otherwise zero

Definition at line 33 of file V24Control.c.

Referenced by main().

00033                                  {
00034 
00035      //if (BoardController::getSwitchState(SWITCH_V24)) {
00036 
00037           // enable interrupt
00038           //BoardController::enableV24Interrupt();
00039           
00040 //        if (newDataAvailable == true || (UCSRA & (1<<RXC))) {
00041 //             newDataAvailable = false;
00042 //             return true;
00043 //        } else {
00044 //             return false;
00045 //        }
00046           
00047           return (UCSRA & (1<<RXC));
00048      //}
00049 
00050      //return false;
00051 }

void V24Control::processCommand (  ) 

process command

Definition at line 240 of file V24Control.c.

References Environment::beamRobotToState(), V24Command::command, V24Command::data, V24Command::dataLength, BoardController::disableV24Interrupt(), Environment::doAction(), BoardController::enableV24Interrupt(), ValueIteration::env, ValueIteration::expMode, ValueIteration::expParameter, flushReceiveBuffer(), Environment::getCurrentState(), ValueIteration::getDistanceCovered(), ValueIteration::getIterationCount(), BoardController::getSwitchState(), LED_EXPLORATION, LED_LEARN, LED_WALK, MAIN_MODE_EXPLORE_FEEDBACK, MAIN_MODE_LEARN, MAIN_MODE_STOP, MAIN_MODE_WALK_POLICY, mainMode, BoardController::msDelay(), newMainMode, BoardController::powerOnLED(), processGetDebug(), processGetExplorationConfig(), processGetGamma(), processGetGridsize(), processGetState(), processSetGamma(), processSetGridsize(), processSetState(), StateSpace::ramtestReadBytes(), StateSpace::ramtestSaveBytes(), receiveCommand(), ValueIteration::resetDistanceCounter(), actionReturn::reward, rx_command, setMainMode(), actionReturn::state, ValueIteration::states, SWITCH_V24, transmitCommand(), transmitReceiveCommandProcessed(), tx_command, V24_COMMAND_COMMAND_ERROR, V24_COMMAND_COMMAND_OK, V24_COMMAND_EXPLORE_FEEDBACK, V24_COMMAND_GET_CURRENT_STATE, V24_COMMAND_GET_CURRENT_STATE_MODE_ITERATIONS, V24_COMMAND_GET_DEBUG, V24_COMMAND_GET_DISTANCE, V24_COMMAND_GET_EXPLORATION_CONFIG, V24_COMMAND_GET_GAMMA, V24_COMMAND_GET_GRIDSIZE, V24_COMMAND_GET_STATE, V24_COMMAND_READ_RAM_BYTES, V24_COMMAND_RESET_DISTANCE_COUNTER, V24_COMMAND_SET_CURRENT_STATE, V24_COMMAND_SET_CURRENT_STATE_MODE_ITERATIONS, V24_COMMAND_SET_DISTANCE, V24_COMMAND_SET_EXPLORATION_CONFIG, V24_COMMAND_SET_GAMMA, V24_COMMAND_SET_GRIDSIZE, V24_COMMAND_SET_STATE, V24_COMMAND_START_LEARNING, V24_COMMAND_START_WALKING, V24_COMMAND_STOP_WALKING, V24_COMMAND_WALK_AND_RETURN, V24_COMMAND_WALK_AND_RETURN_RESPONSE, V24_COMMAND_WRITE_RAM_BYTES, V24_ERRORCODE_UNKNOWN_COMMAND, vi, envPosition::x, and envPosition::y.

Referenced by main().

00240                                 {
00241 
00242      if (BoardController::getSwitchState(SWITCH_V24)) {
00243      
00244           // disable all interrupts
00245           cli();
00246           BoardController::disableV24Interrupt();
00247      
00248           char i=0;
00249           char cmd;
00250           unsigned char* bytes;
00251           int _row, _column;
00252           V24COMMAND tmp_command;
00253                
00254           // turn off LEDs
00255           BoardController::powerOnLED (LED_LEARN, false);
00256           BoardController::powerOnLED (LED_WALK, false);
00257           BoardController::powerOnLED (LED_EXPLORATION, false);
00258      
00259           // disable auto start
00260           //BoardController::autoStart = false;
00261      
00262           // receive command
00263           //if (!commandParsedByIRQ) {
00264                if (!this->receiveCommand ( &rx_command )) {
00265                     this->newMainMode = MAIN_MODE_STOP;
00266                     BoardController::msDelay(1000);
00267                     this->flushReceiveBuffer();
00268                     BoardController::enableV24Interrupt();
00269                     return;
00270                }
00271           //} else {
00272           //   commandParsedByIRQ = false;
00273           //}
00274      
00275           cmd = rx_command.command;
00276      
00277           /***************
00278           * walking mode *
00279           ****************/
00280           if ( cmd == V24_COMMAND_START_WALKING ) {
00281      
00282                // go to start position (0,0)
00283                ENV_POS newPos(0, 0);
00284                vi->env->beamRobotToState(&newPos);
00285                this->newMainMode = MAIN_MODE_WALK_POLICY;
00286                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00287           
00288           /*************
00289           * stop robot *
00290           **************/
00291           } else if ( cmd == V24_COMMAND_STOP_WALKING ) {
00292      
00293                this->newMainMode = MAIN_MODE_STOP;
00294                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00295           
00296           /********************
00297           * send gamma to GUI *
00298           *********************/
00299           } else if ( cmd == V24_COMMAND_GET_GAMMA ) {
00300      
00301                processGetGamma();
00302                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00303      
00304           /************
00305           * set gamma *
00306           *************/
00307           } else if ( cmd == V24_COMMAND_SET_GAMMA ) {
00308      
00309                processSetGamma(&rx_command);
00310                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00311      
00312           /**********************
00313           * set grid dimensions *
00314           ***********************/
00315           } else if ( cmd == V24_COMMAND_SET_GRIDSIZE ) {
00316      
00317                processSetGridsize(&rx_command);
00318                
00319           /*******************************
00320           * send current grid dimensions *
00321           ********************************/
00322           } else if ( cmd == V24_COMMAND_GET_GRIDSIZE ) {
00323      
00324                processGetGridsize();
00325                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00326      
00327           /***************************************
00328           * set a state (Value+rewards)          *
00329           ****************************************/
00330           } else if ( cmd == V24_COMMAND_SET_STATE ) {
00331      
00332                processSetState(&rx_command);
00333      
00334           /**************************
00335           * send a state to the GUI *
00336           ***************************/
00337           } else if ( cmd == V24_COMMAND_GET_STATE ) {
00338           
00339                processGetState(&rx_command);
00340      
00341           /*****************************************************
00342           * returns the exploration/exploitation configuration *
00343           ******************************************************/
00344           } else if ( cmd == V24_COMMAND_GET_EXPLORATION_CONFIG ) {
00345           
00346                processGetExplorationConfig();
00347      
00348           /**********************************************
00349           * returns user defined debug information *
00350           ***********************************************/
00351           } else if ( cmd == V24_COMMAND_GET_DEBUG ) {
00352           
00353                processGetDebug();
00354 
00355           /*************************
00356           * RAM-Test - write bytes *
00357           **************************/
00358           } else if ( cmd == V24_COMMAND_WRITE_RAM_BYTES ) {
00359      
00360                this->newMainMode = MAIN_MODE_STOP;
00361      
00362                // write random numbers into memory
00363                vi->states->ramtestSaveBytes(  
00364                     ((rx_command.data[0]*256) + rx_command.data[1]), // Address
00365                     &(rx_command.data[2]),  // Pointer to data
00366                     rx_command.dataLength-2 // size
00367      
00368                );
00369                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00370      
00371           /************************
00372           * RAM-Test - read bytes *
00373           *************************/
00374           } else if ( cmd == V24_COMMAND_READ_RAM_BYTES ) {
00375      
00376                // stop main program
00377                this->newMainMode = MAIN_MODE_STOP;
00378      
00379                // create commando structure
00380                tmp_command.command = V24_COMMAND_WRITE_RAM_BYTES;
00381                tmp_command.dataLength = rx_command.data[2]+2; //
00382                tmp_command.data[0] = rx_command.data[0];
00383                tmp_command.data[1] = rx_command.data[1];
00384      
00385                // read data from RAM
00386                vi->states->ramtestReadBytes(  
00387                     ((rx_command.data[0]*256) + rx_command.data[1]), // address
00388                     &(tmp_command.data[2]),   // data pointer
00389                     rx_command.data[2]   // size
00390                );
00391      
00392                // send back to GUI
00393                if (!this->transmitCommand (&tmp_command)) return;
00394                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00395      
00396           /***********************************
00397           * explore all rewards            *
00398           ************************************/
00399           } else if ( cmd == V24_COMMAND_EXPLORE_FEEDBACK ) {
00400      
00401                this->newMainMode = MAIN_MODE_EXPLORE_FEEDBACK;
00402                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00403      
00404           /***********************************
00405           * learning only mode             *
00406           ************************************/
00407           } else if ( cmd == V24_COMMAND_START_LEARNING ) {
00408      
00409                this->newMainMode = MAIN_MODE_LEARN;
00410                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00411 
00412           /**********************************
00413           * returns the distance traveled   *
00414           ***********************************/
00415           } else if (cmd == V24_COMMAND_GET_DISTANCE ) {
00416 
00417                signed long int _distance = vi->getDistanceCovered();
00418                unsigned char* bytes = (unsigned char*)&_distance;
00419 
00420                tx_command.command = V24_COMMAND_SET_DISTANCE;
00421                tx_command.dataLength = 0x04;
00422                tx_command.data[0] = bytes[0];
00423                tx_command.data[1] = bytes[1];
00424                tx_command.data[2] = bytes[2];
00425                tx_command.data[3] = bytes[3];
00426 
00427                if (!this->transmitCommand (&tx_command)) return; 
00428                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00429 
00430           /**************************
00431            * reset distance counter *
00432            **************************/
00433           } else if (cmd == V24_COMMAND_RESET_DISTANCE_COUNTER ) {
00434 
00435                vi->resetDistanceCounter();
00436                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00437 
00438           /***************************
00439            * set exploration config  *
00440            ***************************/
00441           } else if (cmd == V24_COMMAND_SET_EXPLORATION_CONFIG ) {
00442 
00443                unsigned char* bytes;
00444                register char i;
00445           
00446                // exploration parameter
00447                bytes = (unsigned char*)&vi->expParameter;
00448                for (i=0; i < sizeof(vi->expParameter); i++) {
00449                     bytes[i] = rx_command.data[i];
00450                }
00451 
00452                // exploration mode           
00453                bytes = (unsigned char*)&vi->expMode;
00454                bytes[0] = rx_command.data[sizeof(vi->expParameter)];
00455 
00456                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00457 
00458           /***********************************
00459           * send current position, main-mode and iteration-count to GUI    *
00460           ***********************************/
00461           } else if (cmd == V24_COMMAND_GET_CURRENT_STATE_MODE_ITERATIONS ) {
00462      
00463                unsigned long int _itCount = vi->getIterationCount();
00464                unsigned char* bytes = (unsigned char*)&_itCount;
00465                signed char wert;
00466                
00467                tx_command.command = V24_COMMAND_SET_CURRENT_STATE_MODE_ITERATIONS;
00468                tx_command.dataLength = 0x09;
00469                
00470                ENV_POS pos;
00471                vi->env->getCurrentState(&pos);
00472                tx_command.data[0] = pos.y;
00473                tx_command.data[1] = pos.x;
00474                tx_command.data[2] = (unsigned char)this->mainMode;
00475                tx_command.data[3] = bytes[0];
00476                tx_command.data[4] = bytes[1];
00477                tx_command.data[5] = bytes[2];
00478                tx_command.data[6] = bytes[3];
00479                wert = 127;
00480                tx_command.data[7] = *(unsigned char*)&wert;
00481                wert = -127;
00482                tx_command.data[8] = *(unsigned char*)&wert;
00483                
00484      
00485                if (!this->transmitCommand (&tx_command)) return; 
00486                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00487 
00488           /***********************************
00489           * send current position, main-mode and iteration-count to GUI    *
00490           ***********************************/
00491           } else if (cmd == V24_COMMAND_GET_CURRENT_STATE ) {
00492                     
00493                tx_command.command = V24_COMMAND_SET_CURRENT_STATE;
00494                tx_command.dataLength = 0x02;
00495                
00496                ENV_POS pos;
00497                vi->env->getCurrentState(&pos);
00498                tx_command.data[0] = pos.x;
00499                tx_command.data[1] = pos.y;
00500                
00501                if (!this->transmitCommand (&tx_command)) return; 
00502                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00503 
00504      
00505 //        /*********************************************************
00506 //        * receive states (values+rewards) and gamma from the GUI *
00507 //        **********************************************************/
00508 //        } else if (cmd == V24_COMMAND_SET_ALL_STATES_AND_GAMMA ) {
00509 //        
00510 //             // set gamma
00511 //             if (!this->receiveCommand(&tmp_command)) return;
00512 //             processSetGamma(&tmp_command);
00513 //             if (!v24.transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00514 //   
00515 //             // set grid size
00516 //             if (!this->receiveCommand(&tmp_command)) return;
00517 //             processSetGridsize(&tmp_command);
00518 //   
00519 //             for (_row=0; _row < BoardController::states.scalY; _row++) {
00520 //                  for (_column=0; _column < BoardController::states.scalX; _column++) {
00521 //   
00522 //                       // receive state
00523 //                       if (!this->receiveCommand (&tmp_command)) return;
00524 //                       processSetState(&tmp_command);
00525 //                  }
00526 //             }         
00527 //        
00528 //        /********************************************************
00529 //        * send all states (Values+Rewards) and gamma to the GUI *
00530 //        *********************************************************/
00531 //        } else if (cmd == V24_COMMAND_GET_ALL_STATES_AND_GAMMA ) {
00532 //   
00533 //             // send gamma
00534 //             if (!this->receiveCommand(&tmp_command)) return;
00535 //             processGetGamma();
00536 //             if (!v24.transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00537 //   
00538 //             // send grid size
00539 //             if (!this->receiveCommand(&tmp_command)) return;
00540 //             processGetGridsize();
00541 //             if (!v24.transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00542 //   
00543 //             for (_row=0; _row < BoardController::states.scalY; _row++) {
00544 //                  for (_column=0; _column < BoardController::states.scalX; _column++) {
00545 //   
00546 //                       // receive getState Command
00547 //                       if (!this->receiveCommand (&tmp_command)) return;
00548 // 
00549 //                       // send state
00550 //                       processGetState(&tmp_command);
00551 //                  }
00552 //             }         
00553 
00554           // perform next action and return reward to the GUI
00555           } else if (cmd == V24_COMMAND_WALK_AND_RETURN ) {
00556 
00557                ENV_POS tmpPos;
00558 
00559                tx_command.command = V24_COMMAND_WALK_AND_RETURN_RESPONSE;
00560                tx_command.dataLength = 3;
00561 
00562                unsigned char action = rx_command.data[0];
00563                ACTION_RETURN aRet;
00564                vi->env->doAction(action, 100, &aRet);
00565 
00566                /* char reward = vi->moveAndSaveFeedback(
00567                          action, 0, &tmpPos);
00568                */
00569 
00570                tx_command.data[0] = aRet.state.x;
00571                tx_command.data[1] = aRet.state.y;
00572                tx_command.data[2] = aRet.reward;
00573                //tx_command.data[3] = rx_command.command;
00574                //tx_command.data[4] = rx_command.dataLength;
00575                //tx_command.data[5] = action;
00576 
00577 
00578                if (!this->transmitCommand (&tx_command)) return; 
00579                //if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return;
00580 
00581                this->setMainMode(MAIN_MODE_STOP);
00582 
00583           /*******************************************************************************
00584           * return "UNKNOWN COMMAND" in case of an unknown command
00585           *******************************************************************************/
00586           } else {
00587                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_ERROR, V24_ERRORCODE_UNKNOWN_COMMAND)) return;
00588           }
00589      
00590      
00591           // enable serial interrupt
00592           BoardController::enableV24Interrupt();
00593      }
00594 }

Here is the call graph for this function:

bool V24Control::processGetDebug (  )  [private]

returns user defined debug information

Definition at line 711 of file V24Control.c.

References V24Command::command, ValueIteration::currentExpProbability, V24Command::data, V24Command::dataLength, BoardController::getSwitchState(), NUM_ACTIONS, SWITCH_V24, transmitCommand(), tx_command, V24_COMMAND_GET_DEBUG, and vi.

Referenced by processCommand().

00711                                  {
00712 
00713      if (BoardController::getSwitchState(SWITCH_V24)) {
00714      
00715           V24COMMAND tx_command;
00716      
00717           tx_command.command = V24_COMMAND_GET_DEBUG;
00718           tx_command.dataLength = 10;
00719 
00720           register char i;
00721 
00722           unsigned char* bytes = (unsigned char*)&(vi->currentExpProbability);
00723           for (i=0; i < tx_command.dataLength; i++) {
00724                tx_command.data[i] = bytes[i];
00725           }
00726 
00727           for (i=4; i<tx_command.dataLength; i++) {
00728                tx_command.data[i] = rand()%(NUM_ACTIONS);
00729                srand (rand()+1);
00730           }
00731      
00732           if (!transmitCommand (&tx_command)) return false;
00733           return true;
00734      }
00735 }

Here is the call graph for this function:

bool V24Control::processGetExplorationConfig (  )  [private]

returns exploration parameter

Definition at line 639 of file V24Control.c.

References V24Command::command, V24Command::data, V24Command::dataLength, ValueIteration::expMode, ValueIteration::expParameter, BoardController::getSwitchState(), SWITCH_V24, transmitCommand(), tx_command, V24_COMMAND_SET_EXPLORATION_CONFIG, and vi.

Referenced by processCommand().

00639                                              {
00640 
00641      if (BoardController::getSwitchState(SWITCH_V24)) {
00642      
00643           V24COMMAND tx_command;
00644           unsigned char* bytes;
00645           register char i;
00646      
00647           tx_command.command = V24_COMMAND_SET_EXPLORATION_CONFIG;
00648           tx_command.dataLength = 5;
00649 
00650           // Exploration Parameter
00651           bytes = (unsigned char*)&(vi->expParameter);
00652           for (i=0; i < sizeof(vi->expParameter); i++) {
00653                tx_command.data[i] = bytes[i];
00654           }
00655 
00656           // Exploration Mode
00657           tx_command.data[4] = vi->expMode;
00658           
00659      
00660           if (!transmitCommand (&tx_command)) return false;
00661           return true;
00662      }
00663 }

Here is the call graph for this function:

bool V24Control::processGetGamma (  )  [private]

send gamma to GUI

Definition at line 669 of file V24Control.c.

References V24Command::command, V24Command::data, V24Command::dataLength, ValueIteration::gamma, BoardController::getSwitchState(), SWITCH_V24, transmitCommand(), tx_command, V24_COMMAND_SET_GAMMA, and vi.

Referenced by processCommand().

00669                                  {
00670 
00671      if (BoardController::getSwitchState(SWITCH_V24)) {
00672      
00673           V24COMMAND tx_command;
00674           unsigned char* bytes;
00675           register char i;
00676      
00677           tx_command.command = V24_COMMAND_SET_GAMMA;
00678           tx_command.dataLength = 4;
00679           bytes = (unsigned char*)&(vi->gamma);
00680      
00681           for (i=0; i < tx_command.dataLength; i++) {
00682                tx_command.data[i] = bytes[i];
00683           }
00684      
00685           if (!transmitCommand (&tx_command)) return false;
00686           return true;
00687      }
00688 }

Here is the call graph for this function:

bool V24Control::processGetGridsize (  )  [private]

send grid-size to GUI

Definition at line 741 of file V24Control.c.

References V24Command::command, V24Command::data, V24Command::dataLength, ValueIteration::env, Environment::getCurrentState(), BoardController::getSwitchState(), SWITCH_V24, transmitCommand(), tx_command, V24_COMMAND_SET_GRIDSIZE, vi, envPosition::x, and envPosition::y.

Referenced by processCommand().

00741                                     {
00742 
00743      if (BoardController::getSwitchState(SWITCH_V24)) {
00744      
00745           V24COMMAND tx_command;
00746      
00747           tx_command.command = V24_COMMAND_SET_GRIDSIZE;
00748           tx_command.dataLength = 2;
00749 
00750           ENV_POS pos;
00751           vi->env->getCurrentState(&pos);
00752 
00753           tx_command.data[0] = pos.y;
00754           tx_command.data[1] = pos.x;
00755      
00756           if (!transmitCommand (&tx_command)) return false;
00757           return true;
00758      }
00759 }

Here is the call graph for this function:

bool V24Control::processGetState ( V24COMMAND cmd  )  [private]

send a specific state to the GUI

Definition at line 795 of file V24Control.c.

References V24Command::command, V24Command::data, V24Command::dataLength, ValueIteration::env, Environment::getDiscretization(), StateSpace::getState(), BoardController::getSwitchState(), ValueIteration::states, STATESIZE, SWITCH_V24, tmpState, transmitCommand(), transmitReceiveCommandProcessed(), tx_command, V24_COMMAND_COMMAND_ERROR, V24_COMMAND_COMMAND_OK, V24_COMMAND_SET_STATE, V24_ERRORCODE_GRIDSIZE_TOO_LARGE, vi, envPosition::x, and envPosition::y.

Referenced by processCommand().

00795                                                 {
00796 
00797      if (BoardController::getSwitchState(SWITCH_V24)) {
00798      
00799           ENV_POS pos, d;
00800           vi->env->getDiscretization(&d);
00801 
00802           V24COMMAND tx_command;
00803           pos.x = cmd->data[1];
00804           pos.y = cmd->data[0];
00805 
00806           
00807           if (pos.y >= d.y || pos.x >= d.x) {
00808                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_ERROR, V24_ERRORCODE_GRIDSIZE_TOO_LARGE)) return false;
00809                return false;
00810           } else {
00811      
00812                // get state
00813                vi->states->getState(&pos, &tmpState);
00814                unsigned char* bytes = (unsigned char*)&tmpState;
00815           
00816                tx_command.command = V24_COMMAND_SET_STATE;
00817                tx_command.dataLength = STATESIZE+2;
00818                tx_command.data[0] = pos.y;
00819                tx_command.data[1] = pos.x;
00820           
00821                for (unsigned char i=0; i < STATESIZE; i++) {
00822                     tx_command.data[2 + i] = bytes[i];
00823                }
00824      
00825                if (!this->transmitCommand (&tx_command)) return false;
00826                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return false;
00827                return true;
00828           }
00829      }
00830 }

Here is the call graph for this function:

void V24Control::processSetGamma ( V24COMMAND cmd  )  [private]

set gamma in Value-Iteration

Definition at line 693 of file V24Control.c.

References V24Command::data, ValueIteration::gamma, BoardController::getSwitchState(), SWITCH_V24, and vi.

Referenced by processCommand().

00693                                                 {
00694 
00695      if (BoardController::getSwitchState(SWITCH_V24)) {
00696      
00697           unsigned char* bytes;
00698           register char i;
00699      
00700           bytes = (unsigned char*)&vi->gamma;
00701      
00702           for (i=0; i < 4; i++) {
00703                bytes[i] = cmd->data[i];
00704           }
00705      }
00706 }

Here is the call graph for this function:

bool V24Control::processSetGridsize ( V24COMMAND cmd  )  [private]

set local grid-size

Definition at line 764 of file V24Control.c.

References V24Command::data, BoardController::getSwitchState(), MAX_STATES, SWITCH_V24, transmitReceiveCommandProcessed(), V24_COMMAND_COMMAND_ERROR, V24_COMMAND_COMMAND_OK, V24_ERRORCODE_GRIDSIZE_TOO_LARGE, and vi.

Referenced by processCommand().

00764                                                    { 
00765 
00766      if (BoardController::getSwitchState(SWITCH_V24)) {
00767      
00768           unsigned char _scalX, _scalY;
00769      
00770           _scalY = cmd->data[0];
00771           _scalX = cmd->data[1];
00772      
00773           // check for maximum statespace size
00774           if ((_scalX*_scalY) > (MAX_STATES)) {
00775                if (!transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_ERROR, V24_ERRORCODE_GRIDSIZE_TOO_LARGE)) return false;
00776                return false;
00777 
00778           } else {
00779                //ENV_POS newDiscretization(_scalX, _scalY);
00780                //vi->env->setDiscretization(&newDiscretization);
00781 
00782                // create new VI object with statespace (scalx, scaly)
00783                delete this->vi;
00784                this->vi = new ValueIteration(new ENV_POS(_scalX, _scalY));
00785 
00786                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return false;
00787                return true;
00788           }
00789      }
00790 }

Here is the call graph for this function:

bool V24Control::processSetMotorPosition ( V24Command   )  [private]

bool V24Control::processSetState ( V24COMMAND cmd  )  [private]

set received state (value+rewards)

Definition at line 835 of file V24Control.c.

References V24Command::data, ValueIteration::env, Environment::getDiscretization(), BoardController::getSwitchState(), StateSpace::setState(), ValueIteration::states, STATESIZE, SWITCH_V24, tmpState, transmitReceiveCommandProcessed(), V24_COMMAND_COMMAND_ERROR, V24_COMMAND_COMMAND_OK, V24_ERRORCODE_GRIDSIZE_TOO_LARGE, vi, envPosition::x, and envPosition::y.

Referenced by processCommand().

00835                                                 {
00836 
00837      if (BoardController::getSwitchState(SWITCH_V24)) {
00838 
00839           ENV_POS pos, d;
00840           pos.x = cmd->data[1];
00841           pos.y = cmd->data[0];
00842           vi->env->getDiscretization(&d);
00843                
00844           unsigned char* bytes = (unsigned char*)&tmpState;
00845      
00846           // check, if state exists in grid
00847           if (pos.y>= d.y || pos.x >= d.x) {
00848                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_ERROR, V24_ERRORCODE_GRIDSIZE_TOO_LARGE)) return false;
00849                return false;
00850           } else {
00851           
00852                for (unsigned char i=0; i<STATESIZE; i++) {
00853                     bytes[i] = cmd->data[i + 2];
00854                }
00855      
00856                // save state to memory
00857                vi->states->setState (&pos, &tmpState);
00858                if (!this->transmitReceiveCommandProcessed (V24_COMMAND_COMMAND_OK, 0)) return false;
00859                return true;
00860           }
00861      }
00862 }

Here is the call graph for this function:

bool V24Control::receive ( unsigned char *  data  ) 

function receives one byte from the serial interface and writes it to *data (low-level)

Definition at line 93 of file V24Control.c.

References BoardController::getSwitchState(), LED_POWER, BoardController::msDelay(), BoardController::powerOnLED(), and SWITCH_V24.

Referenced by main(), and receiveCommand().

00093                                              {
00094 
00095      if (BoardController::getSwitchState(SWITCH_V24)) {
00096 
00097           // CTS setzen, damit GUI schicken kann
00098           //PINC |= (1<<CTS); // PC2
00099           BoardController::powerOnLED(LED_POWER, false);
00100           //unsigned char rx;
00101           int errorLoop = 0;
00102      
00103           
00104           // wait a maximum of 1 second until
00105           while (!(UCSRA & (1<<RXC)) && errorLoop <100) {
00106                errorLoop++;
00107                BoardController::msDelay(10);
00108           }
00109 
00110           if (errorLoop == 100)
00111                return false;
00112           
00113           
00114      
00115           // error check
00116           /*if (errorLoop>=100) {
00117                BoardController::powerOnLED(LED_POWER, true);
00118                //BoardController::newMainMode = MAIN_MODE_STOP;
00119                return false;
00120           } else {
00121           */
00122                // return received data
00123                *data = UDR;
00124                BoardController::powerOnLED(LED_POWER, true);
00125           /*
00126                return true;
00127           }
00128           */
00129      }
00130 
00131      return true;
00132 }

Here is the call graph for this function:

bool V24Control::receiveCommand ( V24COMMAND c  )  [private]

receive a commando from the serial interface into *c

Definition at line 185 of file V24Control.c.

References V24Command::command, V24Command::data, V24Command::dataLength, BoardController::getSwitchState(), receive(), and SWITCH_V24.

Referenced by processCommand().

00185                                               {
00186 
00187      unsigned char loopCount, rData, data;
00188      bool sync = false;
00189      char i;
00190 
00191      if (BoardController::getSwitchState(SWITCH_V24)) {
00192 
00193 //        // synchronisation
00194 //        rData = !V24_COMMAND_SYNC_COMMAND;
00195 //        do {
00196 //             if (receive(&rData) && rData==V24_COMMAND_SYNC_COMMAND) {
00197 //                  transmit(V24_COMMAND_SYNC_OK_COMMAND);
00198 //                  sync = true;
00199 //             }
00200 //        } while (!sync);
00201 
00202           // receive command byte
00203           sync = false;
00204           do {
00205                if (receive(&c->command)) {
00206                     //transmit(c->command);
00207                     sync = true;
00208                }
00209           } while (!sync);
00210           
00211           // receive command-length
00212           sync = false;
00213           do {
00214                if (receive(&c->dataLength)) {
00215                     //transmit(c->dataLength);
00216                     sync = true;
00217                }
00218           } while (!sync);
00219 
00220           
00221           // receive command data
00222           for (loopCount=0; loopCount < c->dataLength; loopCount++) {
00223                sync = false;
00224                do {
00225                     if (receive(&c->data[loopCount])) {
00226                          //transmit(c->data[loopCount]);
00227                          sync = true;
00228                     }
00229                } while (!sync);         
00230           }
00231      
00232           return true;
00233      }
00234 }

Here is the call graph for this function:

void V24Control::setMainMode ( int  mainMode  )  [private]

set's the mainMode which can be requested by the PC

Definition at line 880 of file V24Control.c.

Referenced by processCommand().

00880                                           {
00881      this->mainMode = mainMode;
00882 }

void V24Control::transmit ( unsigned char  data  ) 

transmits a byte on the serial interface (low level)

Definition at line 69 of file V24Control.c.

References CTS.

Referenced by main(), and transmitCommand().

00069                                              {
00070 
00071      //if (BoardController::getSwitchState(SWITCH_V24)) {
00072 
00073           //BoardController::enableSerialV24Interface();
00074 
00075           /* wait till transmit buffer is ready */
00076           while (!(UCSRA & (1<<UDRE)));
00077 
00078           /* wait until busy-pin (from RF04) is ready */
00079           while (PINC & (1<<CTS)); // PC2
00080      
00081           /* send data */
00082           UDR = data;
00083      
00084           // wait until transmission is complete
00085           while (!(UCSRA & (1<<TXC)));
00086      //}
00087 }

bool V24Control::transmitCommand ( V24COMMAND c  )  [private]

transmits a command on the serial interface

Definition at line 137 of file V24Control.c.

References V24Command::command, V24Command::data, V24Command::dataLength, BoardController::getSwitchState(), SWITCH_V24, and transmit().

Referenced by processCommand(), processGetDebug(), processGetExplorationConfig(), processGetGamma(), processGetGridsize(), and processGetState().

00137                                                {
00138 
00139      unsigned char loopCount;
00140 
00141      if (BoardController::getSwitchState(SWITCH_V24)) {
00142 
00143      
00144           unsigned char tmp;
00145 
00146 //        // transmit command-byte
00147 //        transmit(V24_COMMAND_SYNC_COMMAND);
00148 //        if (rxtx) {
00149 //             receive(&tmp);
00150 //             if (tmp != V24_COMMAND_SYNC_OK_COMMAND) return false;
00151 //        }
00152 // 
00153 //   
00154           // transmit command-byte
00155           transmit(c->command);
00156           /*if (rxtx) {
00157                receive(&tmp);
00158                if (tmp != c->command) return false;
00159           }*/
00160 
00161           // transmit command-length    
00162           transmit(c->dataLength);
00163           /*if (rxtx) {
00164                receive(&tmp);
00165                if (tmp != c->dataLength) return false;
00166           }*/
00167      
00168           // transmit data
00169           for (loopCount=0; loopCount < c->dataLength; loopCount++) {
00170      
00171                transmit(c->data[loopCount]);
00172                /*if (rxtx) {
00173                     receive(&tmp);
00174                     if (tmp != c->data[loopCount]) return false;
00175                }*/
00176           }
00177      
00178           return true;
00179      }
00180 }

Here is the call graph for this function:

bool V24Control::transmitReceiveCommandProcessed ( unsigned char  _code,
unsigned char  _error 
) [private]

debug: ..

Definition at line 599 of file V24Control.c.

References BoardController::getSwitchState(), and SWITCH_V24.

Referenced by processCommand(), processGetState(), processSetGridsize(), and processSetState().

00599                                                                                           {
00600 
00601      if (BoardController::getSwitchState(SWITCH_V24)) {
00602      
00603 //        V24COMMAND ok_command;
00604 //        ok_command.command = _code;
00605 //   
00606 //        // Im Fehlerfall, den Fehlercode anhängen
00607 //        if (_error > 0) {
00608 //             ok_command.dataLength = 0x01;
00609 //             ok_command.data[0] = _error;
00610 //   
00611 //        // Ansonsten gibt es keinen Datenteil
00612 //        } else {
00613 //             ok_command.dataLength = 0x00;
00614 //        }
00615 //   
00616 //        // Bestätigung senden
00617 //        if (!v24.transmitCommand(&ok_command)) return false;
00618 //   
00619      //   return true;
00620      
00621      }
00622      return true;
00623 }

Here is the call graph for this function:


Field Documentation

int V24Control::mainMode [private]

Definition at line 43 of file V24Control.h.

Referenced by processCommand().

Definition at line 64 of file V24Control.h.

int V24Control::newMainMode [private]

Definition at line 42 of file V24Control.h.

Referenced by getNewMainMode(), and processCommand().

Definition at line 66 of file V24Control.h.

Referenced by processCommand().

bool V24Control::rxtx [private]

Definition at line 63 of file V24Control.h.

Referenced by init().

Definition at line 62 of file V24Control.h.

Referenced by processGetState(), and processSetState().


The documentation for this class was generated from the following files:

Generated on Wed Nov 25 11:27:46 2009 for Crawling Robot Microcontroller Software by  doxygen 1.5.5