NengoRos

Official site of this project: http://nengoros.wordpress.com.

This is Nengoros, a tool which merges Nengo and rosjava_core in order to simulate large-scale hybrid neural systems capable of interfacing with real robotic systems.

Author Jaroslav Vitku, research under [Alife group]((http://artificiallife.co.nf/projects/) on Department of Cybernetics on CTU in Prague.

The simulator is composed of the following parts (all credits to their authors):

Nengo simulator - large scale neural simulations (original readme moved to nengo/README_origNengo.rst)
Rosjava_core - java-based implementation of ROS core

-and potentially with some necessary ROS-components (e.g. messages) included

Together, these packages provide mostly platform-independent tool for simulating hybrid neural systems usable e.g. for experiments with e.g.:

cognitive modeling
neuro-evolution
running simulations of hybrid modular systems composed of arbitrary reusable (ROS) nodes
direct robot control
...and much more.

Javadocs

Note that links in this section will be "browsable" only offline or from the github page of this project on: http://jvitku.github.io/nengoros/.

Nengo/simulator project.
Nengo/simulator-ui project.
Demonodes/basic project.
Jroscore project.
Logic/gates project.
Vivae/vivaesimulator project.
Vivae/vivaeplugin project.

Javadoc for sub-projects which are not available here can be generated from the particular project folder by the following command:

./gradlew javadoc

Te resulting documentation will be placed under [projectName]/build/doc/ folder.

Prerequisites:

Download additional python-based ROS wstool and init it:

pip install -U wstool

or download and "python setup.py install" them from here
or "sudo apt-get install python-wstool" on linux

Create python virtualenv called nengoros (optional):

download fortran
```
  brew install gfortran
```

download virtualenv and wrapper

  sudo pip install virtualenv
  sudo pip install virtualenvwrapper

create ~/.virtualenvs directory

  source /usr/local/bin/virtualenvwrapper.sh

create your virtualenv

  mkvirtualenv nengoros
  source ~/.virtualenvs/nengoros/bin/activate

Install scipy and numpy (also optional):

pip install numpy	
pip install scipy

Installation:

Make folder with workspace:

  mkdir -p ~/workspace && cd ~/workspace

In case of ROS not installed, point the ROS_PACKAGE_PATH into this folder (add to your ~/.profie or ~/.bashrc file )
```
  export ROS_PACKAGE_PATH=~/workspace
```

Download Nengoros configuration:

  git clone -b nengoros-master-v0.0.6 https://github.com/jvitku/nengoros.git

Download all repositories and install them (./tool -h)
```
  cd nengoros
  ./tool -unrf
```
In Eclipse, import all auto-generated projects from nengoros folder (it is necessary to check the check-box search for nested projects, and after importing delete the projectTemplate), clean & build them in Eclipse.

Running

Now the simulator can be launched from class files generated by Eclipse. In order to launch GUI, start the script under nengo/simulator-ui:
```
  ./nengo
```
In order to launch command-line interface, start the:
```
  ./nengo-cl
```

Demos

Demos for the Nengoros can be found on the official project sitehttp://nengoros.wordpress.com.

Additionaly, there are two choices how to learn with NengoROS:

Learn with Nengo part:

All demos of original Nengo simulator are unchanged and can be found under nengo/simulator-ui/demo
To see detailed information about these demo, go to Nengo demos from Waterloo University.

Learn with Nengo-ROS part:

These simple demos show how the modified Nengo can employ ROS nodes in the simulation.
The demo scripts can be found under: nengo/simulatori-ui/nr-demo
The Nengoros currently features sub-project demonodes, where all demos are placed, see its readme for all information.
To se more information go to Nengoros tutorials.

Additional information

###Gradle tests

The project nengo/simulator has the src folder set to: src/java/test/ctu to ensure that all Nengo tests are omitted, in order to run also Nengo tests, set this folder to src/java/test.

###Tool Script

The tool script is used to update the multi-project from repositories. Now, the complete.rosinstall version is suported. Various older versions are placed under .versions folder. In case you want to choose which version to use, e.g. for rosbased (creates .rosinstal file):

wstool init -j8 . .versions/rosbased.rosinstall

Run the tool script:

./tool -unrf

..this will:

update all repositories from remote
compile rosjava_core and install it into ~/.m2 repository
compile and install other nengoros components (e.g. install jroscore into ~/.m2 repo and creates runnable application under jroscore folder etc..)

###Information about updating Nengoros:

THe script tool can update all projects from remote repositories:

	./tool -h

Changelog

Describes development of the project, the TODO chapter can be found in the changelog.md file.

###nengoros-master-v0.0.5

Completely rewritten NeuralModule and DefaultNeuralModule.
Added support for multiple Terminations for Encoder. Each Encoder now has MultiTermination. Now, the following can be used to add the weighted Termination module2.newTerminationFor(F2FPubSub.ann2ros,[0.01,0.1,0.02,0.02]), see nr-demo/basic/multitermination.py.
Written nicer documentation and generated javadoc for all sub-projects (available also online on new webpage)
Added unit tests
Found and fixed many bugs (e.g. in RosUtils)
Code is now much cleaner

###nengoros-master-v0.0.4

Added support for the my modification of the Vivae simulator. More precisely: the old version of Vivae support was removed from the Nengoros and placed into the vivae/vivaeplugin project.

###nengoros-master-v0.0.2

Added three possibilities how to sync time between Nengo and ROS nodes: TimeMaster, TimeIgnore and TimeSlave. These are used in the ca.nengo.util.impl.NodeThreadPool.step().
Added demos representing time synchronization in the project demonodes/basic, the corresponding python scripts are located under nr-demo/basic/time*

###nengoros-master-v0.0.1

The first stable version. Version is mainly taken from my older repositories on bitbucket.org.
Includes demos on rosjava, ROS nodes and native process.
Communication with ROS nodes is synchronous or asynchronous