StateSpace.c

Go to the documentation of this file.
00001 #include "StateSpace.h"
00002 
00004 void StateSpace::init() {
00005 
00006      // use internal memory instead of FM24C256
00007      this->useInternalRAM = true;
00008 
00009      // init ram
00010      ram1.init();
00011 }
00012 
00014 void StateSpace::getState (unsigned char _row, unsigned char _column, STATE *_state) {
00015 
00016      unsigned int _addr;
00017      unsigned char i;
00018      unsigned char* _bytes = (unsigned char*)_state;
00019 
00020      // compute memory address
00021      _addr = ((_row * scalX) + _column)*STATESIZE;
00022 
00023      // internal RAM
00024      if (this->useInternalRAM) {
00025           for (i=0; i<STATESIZE; i++) {
00026                _bytes[i] = internStateSpace[(_addr + i)];
00027           }
00028 
00029      // SPI memory
00030      } else {
00031           ram1.readBytes(_addr, (unsigned char*)&_state[0], STATESIZE);
00032      }
00033 }
00034 
00036 void StateSpace::setState (unsigned char _row, unsigned char _column, STATE *_state) {
00037 
00038      unsigned int _addr;
00039      unsigned char i;
00040      unsigned char* _bytes = (unsigned char*)_state;
00041 
00042      // compute memory address
00043      _addr = ((_row * scalX) + _column)*STATESIZE;
00044 
00045      // internal RAM
00046      if (this->useInternalRAM) {
00047           for (i=0; i<STATESIZE; i++) {
00048                internStateSpace[_addr + i] = _bytes[i];
00049           }
00050 
00051      // SPI Memory
00052      } else {
00053           ram1.writeBytes(_addr, (unsigned char*)&_state[0], STATESIZE);
00054      }
00055 }
00056 
00058 void StateSpace::setValue(unsigned char _row, unsigned char _column, float _value) {
00059 
00060      STATE _s;
00061      this->getState ( _row, _column, &_s );
00062      _s.value = _value;
00063      this->setState ( _row, _column, &_s );
00064 }
00065 
00067 void StateSpace::setFeedback(unsigned char _row, unsigned char _column, unsigned char _action, char _fb) {
00068 
00069      STATE _s;
00070      this->getState (_row, _column, &_s);
00071 
00072      if (_action == UP) {
00073           _s.feedback_up = _fb;
00074      } else if (_action == DOWN) {
00075           _s.feedback_down = _fb;
00076      } else if (_action == LEFT) {
00077           _s.feedback_left = _fb;
00078      } else if (_action == RIGHT) {
00079           _s.feedback_right = _fb;
00080      }
00081 
00082      this->setState (_row, _column, &_s);
00083 }
00084 
00086 double StateSpace::getValue(unsigned char _row, unsigned char _column) {
00087      STATE _s;
00088      this->getState (_row, _column, &_s);
00089      return _s.value;
00090 }
00091 
00093 char StateSpace::getFeedback (unsigned char _row, unsigned char _column, unsigned char _action) {
00094 
00095      STATE _s;
00096      this->getState (_row, _column, &_s);
00097 
00098      if (_action == UP) {
00099           return _s.feedback_up;
00100      } else if (_action == DOWN) {
00101           return _s.feedback_down;
00102      } else if (_action == LEFT) {
00103           return _s.feedback_left;
00104      } else if (_action == RIGHT) {
00105           return _s.feedback_right;
00106      }
00107 }
00108 
00109 
00111 void StateSpace::ramtestSaveBytes(unsigned int _addr, unsigned char *data, unsigned char _length) {
00112 
00113      unsigned char* statesPtr = (unsigned char*)&internStateSpace[0];
00114      unsigned char i;
00115 
00116      if (this->useInternalRAM) {
00117           for (i=0; i<_length; i++) {
00118                statesPtr[_addr + i] = data[i];
00119           }
00120 
00121      } else {
00122           ram1.writeBytes(_addr, data, _length);
00123      }
00124 }
00125 
00127 void StateSpace::ramtestReadBytes(unsigned int _addr, unsigned char *data, unsigned char _length) {
00128 
00129      unsigned char* statesPtr = (unsigned char*)&internStateSpace[0];
00130      unsigned char i;
00131 
00132      if (this->useInternalRAM) {
00133           for (i=0; i<_length; i++) {
00134                data[i] = statesPtr[_addr + i];
00135           }
00136 
00137      } else {
00138           ram1.readBytes(_addr, data, _length);
00139      }
00140 }
00141 
00143 unsigned int StateSpace::getMemorySize() {
00144 
00145      // Interner RAM
00146      if (this->useInternalRAM) {
00147           return sizeof(internStateSpace);
00148 
00149      // SPI RAM
00150      } else {
00151           return 65535;
00152      }
00153 }
00154 

Generated on Wed Mar 25 12:58:40 2009 for Crawling Robot Microcontroller Software by  doxygen 1.5.5