______ _________ _____ ___ / / /__ __ )_______ /_ __ /_/ /__ __ | __ \ __/ _ __ / _ /_/ // /_/ / /_ /_/ /_/ /_____/ \____/\__/ HBot is a hobby project aiming at building an open-source robotic software stack for embedded devices (e.g. a linux smartphone). This software shall control a robot (homemade wheeled robot with an IR sensor) for autonomous mapping, localization, pathfinding and interactions with people (there is still a lot of work to be done yet). Focus is on extensibility (to other robots and embedded platforms) and simplicity (lua scripting for determining robot configuration and behavior).
I'm working on modifying some of the core elements of hbot, bringing MQTT and MsgPack for M2M and C++/lua data transfer. I'm very tempted to change the current signal/slot paradigm with a pub/sub system, hoping that the code would be more modular and less “spaghetti”. More to come soon.
HBot v0.8.0 is out.
As announced earlier, this new version has support for Lego NXT 2.0 and opencv. There's also concrete support for roomba with rootooth, that makes HBot easier to use directly from a computer (with bluetooth and rootooth). Video tracking is new, so there's probably room for improvement. But with a fixed camera you can now track your robot and project its position on a map, which is pretty cool in my opinion :)
A new version of HBot is coming soon! I've been working recently on integrating opencv to bring robot tracking with an external camera. That seems to apply relatively well to the roomba, which would open the possibility to guide a roomba from room to room, provided there is a camera to track it. I'm working on fix cameras now (not even tilt&pan), and it's still at prototype level. As soon as this is in a working state, I'll release HBot 0.8.0, then I'll have a closer look at this Internet of Things trend. I'd like to see how the signal/slot mechanism could fit into the MQTT protocol. Turning a robot into a sensor network is probably not new, but still, it seems exciting to add that to HBot!
Thanks to the work done by Anders Søborg and Nicolas Guilbert, support for Lego Mindstorms NXT 2.0 is coming to HBot! There's more to come, with some native support for bluetooth (instead of relying on the platform's capabilities to bind to a device's serial port profile), and improved lua configuration. Progress are slow, but new things keep coming :)
HBot v0.7.9 is out.
One year since the last release, and there's been a lot of refactoring. Cppunit has been replaced by Google Test, which provides more flexibility and a simpler framework. Some bugs have been fixed. But more importantly, all the stack is now asynchronous, which makes it potentially single-threaded. All socket, serial and other communication is using boost, revolving around ASIO's infrastructure for building an event loop. Hopefully that will enable further development for inter-process communication and more!
A lot of exciting things are happening in HBot's infrastructure. Most of the tasks are replaced by asynchronous actions. The introduction of a concept of event loop makes it easier to manage multiple tasks without the hassle of inter-thread synchronization. Also, all the networking and serial code is now taken care of by boost, a very efficient and portable library. Overall, networking, serial, signal/slots, threads and event loop are gradually handled by boost. Work is almost complete, but it forced the usage of asynchronous events replacing the parts that were blocking. Currently, I'm busy making the moves toward a point asynchronous, instead of blocking for the whole time of the move. It's quite a change compared to the current concept.
Also, I've acquired a rootooth, a bluetooth module to remotely communicate with Roomba. Rootooth from the last years have quite some problems configuring though, read the dedicated page if you need to learn more.
HBot v0.7.8 is out.
Again not many new features, but I am pretty happy with code clean-up, the new logging infrastructure (C+ + style replaced the C style), and the reworked GridMap code. This was really necessary before going forward. I have been investigating stuff that I'd really like to start implementing for the next release. That, plus some roomba work, plus some support for the Lego Mindstorm NXT 2.0. That should keep me quite busy I think.
Happy new year!
HBot v0.7.7 is out.
This release took about 7 months to be released, but that does not mean it contains much more than another release :) My life has been pretty busy this year (and will continue being so in the future), and there is still a lot of things I want to improve on hbot. That will probably results in 6-months releases, but what is being put in place is really challenging. I want to get a more professional result, so that means a better build system (I switched to cmake to support more flexibility more easily), a unit-test framework (barely started), regular code refactoring, etc. On the features aspect, I have to say I want to focus on one thing, a good support for remote controlling a roomba. Once it's there, I will consider bringing more intelligence to the beast. I will try to update this site more regularly, not waiting for releases to give news! In the meantime, have fun in 2011 :)
Short update, the project is still alive, though stalling a bit, because I try to interface hbot with the linux bluetooth stack (bluez), and it is far from being easy. Bluez needs dbus, dbus has very low-level interface so you need a binding like the ones available in GLib and Qt, but I don't want to depend on these (potentially huge) libraries. So I try to use dbus-c++, an almost-working C++ binding library (the parts that work are really nice by the way). So expect better news soon!
(This message got lost in the limbos of the interwebs for some strange reason, but here it is)
HBot v0.7.6 is out.
A lot of partially implemented stuff here: a new hardware interface started making its way to HBot. OSIF is an initiative for creating a open-sourced hardware, firmware and software for a servo-motor. The hardware controller used is a glorified USB-I²C converter, since the open-servos talk in I²C. For now, libOSIF is integrated to hbot source tree, and a dummy controller has been created around it. Some GPS support has been started too. Next version should see integration of bluetooth to hbot, so that bluetooth GPS connection burden will be off the system and handled by hbot. Lua bindings have been reworked (for a better integration). Finally, an Artificial Neural Network (ANN) library has been integrated, and can be used right now. It has the usual limits of ANNs, so don't expect miracles out of it; I could barely use it have simulated hbot learn an obstacle avoidance algorithm.
HBot v0.7.5 is out.
Some cosmetic stuff in there: “rare” 3rd party libraries are included in source tree for sake of simplicity, “SensorControl” changed its name to a more precise “AreaSensor”, introducing SensorArray and BumperArray, for Roomba first, we will see how player fits in that. The biggest move here is an effort to push down to the “senses” directory everything that is hardware-specific. This means that luabot, botmgt, as well all the algorithm directories will be hardware agnostic: if you add a new platform in senses, all the rest works out of the box. As a conclusion I (finally!) wrote down the luabot documentation, that you can find it here. Do not hesitate, subscribe to the hbot mailing list to get more details and give feedback!
As hbot grows, the needs to have more precise documentation, bug reporting and some discussion on new features arise. One of them is ready: an hbot-dev mailing list has been set up (thanks to Benoit), you can subscribe here. A second topic, which is the documentation, is on its way, using doxygen. You can find some references there already, it will need some polish and more effort to be complete (only luabot configuration phase is documented for the time being). Finally a bug tracker should be ready soon. Enjoy!
HBot v0.7.4 is out.
As previously said, there has not been much progress these last 2 months, so this release is merely to start new things on a fresh ground. The main point is the integration of OpenSteer, a library specialized in generating some movement behaviors for moving elements. It has been thought for virtuality, e.g. for creating a crowd that walks on the street, but with some adaptation I think it is possible to use it for some interesting behaviors in a robot, for example follow somebody, avoid obstacles, etc. The approach taken here enables several behaviors to be integrated into one steering. That is another thing brought into HBot in this version: the possibility to have several “move” events being integrated at the low-level movement manager. There is still a long way to go before the actual code acts like this short description (let's first make OpenSteer and HBot physical engine talk to each other), but I think it should be very exciting (if it works).
Happy new year, fellow roboticists! The project is on hold for 2 months now, because I changed job and country, and I am now living near Switzerland, Geneva area. When I get an internet access back I will be able to keep the project alive.
HBot v0.7.3 is out.
This new version brings a better TA* pathfinding, with funnelling optimization. The PID algorithm received much love, with a more generic approach, a better behavior regarding the different tasks asked to it, and some other niceties (e.g. bumper stops PID). There is also a functional OccupancyMapGenerator, that fills a map on robot move, with the trace of the robot. This will enable “blind” robots to create a map without sensors. Finally, some improvements in project code layout and genericity…
Progresses are slow, because the code at stake becomes quite complex and the problems to tackle are rather hard. Anyway PID moves are better, roomba odometry get better (yet not perfect), and a new map generator appeared: occupancy map generator, for marking as free space the places where the robot went. There is also some work in progress on making a beagleboard work, and preliminary investigations on the OpenSteer library (for autonomous move decisions) and OpenCV library (for computer vision).
HBot v0.7.2 is out.
Not much features, for this version prepared for a long time, but big features:
With HBot v0.7.2 you can use HBot-Eyes (aug09 version), which lets you control a roomba with a gamepad (start/stop the vacuum cleaner with pad buttons); a reflex handler written in lua makes the roomba go back when an obstacle is hit. It also makes several irritated beeps, and cuts gamepad for some seconds :)
It has been a long time from the last post. What kept me from progressing is some problem connecting the Roomba to my EZX phone, but this is solved now! I have been able to control the Roomba, pilot it and turn vacuum cleaners on/off with a gamepad plugged on the pyhbot machine. The control of the roomba is realized with HBot and player, but reactivity is not satisfactory. So I am currently writing my own roomba controller, to get a fine-grain feedback from the Roomba. As soon as I can, I post a video demonstrating HBot on Roomba. Stay tuned.
Find out what's coming in hbot!
This plan will change regularly to show project advancement.
You can also track wiki changes through RSS feed.
HBot v0.7.1 is out.
Introducing bumper management (very useful for the roomba, because it is almost the only sensors available) and more luabot interactions. Now you can write a signal handler in lua. More to come soon, for hbot 1st anniversary!
I received my roomba, and I have to say I am rather satisfied with it! I am already thinking about the ton of (not so) stupid things that can be realized with this object. On top of my priority list is to simply adapt basic hbot (as of v0.7.0) and command the roomba with a gamepad (with buttons for starting the vacuum cleaner). On bottom of the list (but high on the “fun” list), is to adapt a plate on it, and have it bring drinks and pringles when I invite people ;)
HBot v0.7.0 is out!
Work on SLAM has started, but needs a lot of tuning. I also focused on a new UI application:
pyhbothbot-eyes. Distant pad control and display of map updates were needed to go further on the path to SLAM.
I am also waiting eagerly for a roomba I ordered a few days ago, let's hope it will fulfill both objectives of cleaning my room AND being hackable!
Oh, and… hbot is now beta! \o/
HBot v0.6.5 is out!
With this version comes a scripting API based on lua. Why lua? Because it is simple enough for everyone to try hbot without programming knowledge, it is easily embeddable, and it has a small footprint. Have a look at the luabot documentation. There is also a better integration to player/stage, now usable for testing without real hardware.
Finally, all dependencies are now optional; for example not having CGAL will disable vectorial maps, but the rest will be usable.
I am starting this news topic to provide more information to anyone finding this page. Things are greatly improving lately, the integration of the player/stage project enable developping without actual hardware; the integration of lua provides an easy user interface; there will soon be an GUI application for better control of the mapping activity of the robot. Lots of software topics are to be implemented in the next version (v0.6.5), but there will be a focus on SLAM algorithms in a near future.