nicer readme

README.md

 # general info
-- c++ implementation because python is too slow, and we're just doing math anyway 
-- but there are python versions of everything for students who don't need the best performance
-# some specifics
-- using the ur_rtde implementation of the client-side real-time interface for ur robots
-- using pinocchio for dynamics intergration on the client side
-- basic closed-loop inverse kinematics control is implemented, more algorithms should be added
-- some basic tests will be here as well, other projects built on this will be in separate repos
-
-# TODO
-focus: doing it all in C++ as it will most likely be equally easy when the rust falls off,
-but it will work better and be easier to debug in the future
-	6.1 get ur5e urdf that works
-		---> you need to generate it from officile ur xacro files
-	6.2 essentially copy-paste pinocchio sample clik, but implement your inverse-kinematics algorithms
-https://gepettoweb.laas.fr/doc/stack-of-tasks/pinocchio/master/doxygen-html/md_doc_b-examples_d-inverse-kinematics.html
-	6.3 get the ur simulator to work so that you can see things while testing with actual signals
-		(check their github page, their docker does not work atm, just find another one/run it on metal, you
-		  know that the connection is OK)
-	6.4  improvements:
-		- write some getting-started-type documentation so that students aren't intimidated
-		- get pybind for stuff you write in c++ (really no rush there)
-		- re-implement clik so that students can use it
-7. force control on the gripper 
-10. basic environment simulation: dynamics with lugre friction via straight o.d.e. integration
+- all of the code has been used and tested on Ubuntu 22 LTS
+- both Python and C++ implementations are available, there's examples of both (both for the libraries
+  used and for their combination)
+- all of the code is initially written in C++ - ur_rtde uses pybind to generate Python bindings, and
+  so does pinocchio for the most part. thus almost all the functions used are identical across languages, 
+  and so c++ implementations can be looked at to analyse python functionality as well
+- matrix operations are done with Eigen in C++, and NumPy in Python
+# libraries used and their purpose
+- ur_rtde for the client-side real-time interface for ur robots (we have a UR5e)
+- pinocchio for dynamics intergration, and other robotics-related math on the client side
+- gepetto for visualization (has nice integration with pinocchio)
+- Dockerized ur simulator as a simulator (it's a bad simulator, but it uses the same robot-communication API 
+  as the real robot, making coding and testing easier)
+# contents of this repository
+- basic documentation can be found in the docs directory: official UR documentation on the robot's capabilities
+  and its interface, short instructions on installing Ubuntu, ur_rtde, pinocchio, gepetto and the simulator
+- basic closed-loop inverse kinematics control is implemented in both C++ and python. the C++ version
+  uses exponential coordinates and the Lie group formalism, while the Python version uses homogenious
+  transformations and basic matrix operations
+- robot description files: urdf containing both the arm and the gripper, and other urdf-related files
+- more algorithms will be added over time
+- documentation will be expanded according to demand
+- some basic tests will be here as well, while full projects built on this repo will be in separate repos
 

docs/pinocchio.md

@@ -12,4 +12,5 @@ while it's certainly a plus to learn them, you don't need to. you can just use t
 and calculating jacobian functions, and do ther rest of the math with eigen or numpy.
 
 # how to learn how to use pinocchio?
-play around with it in ipython3 
+follow exercises and tutorials from the pinocchio documentation webiste, play around with it in ipython3 (a nicer
+shell than plain python, install with sudo apt-get install ipython3)