Legobot + Base Station 1.0

It's been a while since I wrote about my ongoing hobby project of building a Lego Raspberry Pi tracked vehicle. I've been working on it on and off since the last post, so here's a bunch of updates.

I finally made the plunge and bought a Raspberry Pi UPS Hat (note: does not come with batteries). The reason I held off for so long was mainly for two reasons: the capacity is lower than a separate USB power bank, and I didn't want to faff about with custom wiring and having to worry about short-circuiting things. I ended up caving in because the UPS hat just wasn't that expensive, and faffing about with custom wiring means the end product can be a lot smaller.The big gain you get from a UPS hat is that actually unintterrupted. With every single USB power bank I tried there was always a blip in voltage when plugging the power bank in to mains power that caused the Raspberry Pi to reset itself. No such issue exists when you're using a UPS Hat, and the 2.5A output is more than enough to power two Lego Power Functions XL motors at 8.4V.

Things worked out really well with the UPS hat. Previously I had a separate converter that stepped up the external power bank's 5V USB Power to 9 or 12 volts, which then went into the ThunderBorg motor controller. I found that with the UPS Hat I can pipe the 8.2V input power straight into the ThunderBorg and it's more than enough to drive the two tracks. I ended up having to add an additional switch, because hooking it up to the input power means there's no real way to turn off the power at all, since the ThunderBorg ends up powering the Pi if the UPS hat power switch is turned off. A bit weird, but all in all a lot more compact than my previous solution.

With things getting closer to a finished product I also shortened the Lego power cables, which I had kept intact so far, and was hooking into them with awkward DuPont cables that took up a lot of space. I also made the camera mount more compact by removing the ability to rotate horizontally.

With so much space saved, I managed to add in an additional motor to the front of the vehicle. This motor doesn't connect to anything when the vehicle is driving around. When docked into the base station, this motor can drive any kind of functionality supported by the base station. As you can see from the video below, the base station I built has a retractable ramp which is powered by this custom front motor. Another idea I have is to build a lift for it so I can make the bot look out the window.

I had originally planned to have a worm gear somewhere in the base station winch assembly, but then I figured that the motor resistance is easily enough to hold up the ramp when docked. Plus, as you can see from the second half of the video, you get this cool rapid ramp drop effect just by driving the bot backwards out of the docking station without having to lower the ramp through the winch motor.

The UI shows the video feed and various control buttons for all the motors and lights. It's not clear from the video, but the status bar shows information about battery charge, wifi signal, current wattage, motor voltage and so on. The UPS hat came with a Python library to read the charge percentage, but it did not compensate for the nonlinear dropoff of Li-ion cells, so I had to write a layer on top of that to get a somewhat predictable battery percentage out of it. It's not perfect, but good enough.

Software-wise it's all quite messy. I've been meaning to publish the finished product on github, but the last time I seriously looked at the code was a couple of years ago. The video streaming solution was very unprofessional and optimized to work for the first Raspberry Pi. It definitely needs some polish before I can publish it. But once the software has been published I think I can officially consider this project done. I can't believe I've been at this for several years now. I'll have to find a new hobby..

Posted in Tech | Tagged , ,

Raspberry Pi powered Legobot: latency

I've blogged before about my neverending attempts to build the perfect robot to drive around my apartment remotely. I've gone through a lot of mechanical designs, and had a lot of failures. Eventually I settled on something that was very much simplified compared to my initial ambitions, but it works alright now. It's been serving as my remote camera every time we go on holiday, so it's doing its job. Here's a writeup on the software latencies involved.

At the core of this contraption is a Raspberry Pi that controls a whole bunch of Lego motors, and one set of lights. I wrote my own Python+Django web app to control access to the device from the internet. It uses Django Channels to send the user input to the server-side, where the web app controls the Raspberry Pi's GPIO ports directly. This means it's not very thread-safe, but then it was never really meant to be controlled by more than one user at a time anyway.

For the video stream, I tried a lot of different solutions, but all of them had terrible latency. The problem is that the Raspberry Pi just does not have enough CPU power to encode the video into a stream and send it over a websocket. However, after a long search, I did eventually find a solution someone else developed that's pretty nifty: it uses the native Raspberry Pi video tool to stream the raw (H264-encoded) camera stream directly to a websocket, hosted by a Node.js webserver. This means that the video stream has to be decoded client-side, in the javascript executed by the client's browser, using a nifty js library. (I'll eventually get around to placing links to these libraries, once I remember where I got them from). Turns out this works pretty well!

Here's a really terrible video that shows the latency of the controller software, as served from a web page on my mobile phone, over the phone's 4G connection, so not on the wifi.

This video was taken on my old Canon S110 camera, which has a super slow-mo mode which records at 240 frames per second. So, counting the frames between events, I get these results (averaged over a couple of different videos):

  • Time between pushing the 'lights on' button in the mobile phone browser and the UI registering the event (client-side-only lag): ~31 frames = ~129ms.
  • Time between the button being pushed, and the lights turning on in the video: ~12 frames = ~5ms. I'm guessing this is very short because the actual action is being sent to the Raspberry Pi well before the UI update begins, so it'll overlap with the first action. Time between finger push and real-life consequence: about 135ms.
  • Time until the mobile phone video stream shows the lights being turned on (since the lights actually turned on): ~55 frames = ~229ms.

All in all it's close to half a second between requesting the action, and actually seeing confirmation of the action on-screen. And that's on a fairly reliably mobile connection close to my home. It's a different story altogether on crappy hotel wifi halfway across the world, although I've also been to some amazing hotels in Japan where the speed was very similar to the speeds in this test.

Still to do: open-source the Raspberry Pi software I wrote for this. More to come!

Posted in Tech | Tagged ,

Raspberry Pi controlled Lego car part 3

Things have not gone smoothly since the last post. I can't seem to stop spending money on this..

Last time my goal was to build a two two-speed gearboxes, connected via a gear switch lever, controlled via servo motor, that will allow me to switch both gearboxes simultaneously via the Raspberry Pi. I have absolutely no reason to do this. The car will work just fine with only one gear. It just seemed like an interesting thing to do. It led to me researching some rather complicated things on Wikipedia, but given that I only have one differential and (despite what these posts might make you believe) am trying to keep it simple, I decided to go with the dual gearbox option. I had already bought extra parts for this and felt too stubborn to give up on it.

That was a few weeks ago. Here's what I initially came up with.

The first image shows the interior: the M motor controls two mini actuators. You can see the top one, there's a bottom one as well controlling the axis in the other direction. The second image shows both gearboxes attached. I had to give up my plan to use the servo motor almost right away, because getting the gearing right for the servo motor to shift the axis exactly 1 block left or right proved nearly impossible, and very easy to go wrong over time. In this first design I had planned to use the regular M motor with a clutch gear to make it stop when it reached the end of its travel, but due to the way I connected the gears it didn't quite work. I also realized during building this that I couldn't have two identical gearboxes; I had to mirror the design in order for the gear-shift actuators to select the same gear every time.

This design was way more sturdy than the one from the previous post, but still not quite study enough. Other than that there are two major problems with this design. The first is that it is just massive. Both driving axes are mounted very far away from each other, meaning I needed lots of tracks to connect the two. My prototype had completely flat tracks in-between the two axes, which resulted in a massive contact surface with our thick carpet. The prototype was geared the same way as previous ones, but simply did not have enough power to move.

The second problem is the way it shifts the gear-shift axes. Each actuator is connected to gear axle with only one point, so in order to shift gear it either performs a push or a pull motion. There's nothing stopping the actuator mount point from shifting other than two little stoppers on the axle. This turned out to be rather weak, and they ended up getting pushed or pulled away from the bit that connects the actuator to the axle, making its range wider and wider until it just stopped working completely after a few shifts. Fail.

Last time I mentioned that the USB-to-9v cable that I bought was faulty, and that I was actually able to power both the Pi and the motors from a single USB battery pack. This turned out to be mostly true, yet ended up not helping me in any way. I bought a new USB-to-9v cable, and this time it did work correctly on my battery pack of choice I was using, a Tecknet 10000mah pack, which is very thin and easy to hide inside the Lego. Sadly I found out after getting the new USB cable that this battery pack doesn't provide the amperage needed to power two XL motors at the same time. It just barely manages, but as soon as you put some load on it then it shuts down and doesn't restart.

That led me into yet another unexpected quest: that of finding the perfect USB battery pack: one that has two USB connectors for input, plenty of amps on each output, and ideally allows for passthrough charging without blipping the power or requiring you to press a button after plugging/unplugging. I have spent a long time searching for a suitable battery pack on the internet and have found absolutely nothing that satifies all of these requirements. There's plenty of powerful battery packs, even powerful battery packs that allow passthrough charging, but none of them do it without blipping the power or requiring a button push to resume. There are some boards for the Raspberry Pi that allow multiple power inputs, which I think would work for autonomous recharging. That's yet more money to spend on this though, and makes things even more complicated, so I'm holding off on that for now.

Eventually I tore apart the previous prototype and started on a new gearbox assembly. I considered building the gearbox bit vertically, but eventually decided to go horizontal again for the sake of simplicity. I increased the length of the gearbox axles by one, which allows me to connect to the gear-shifting axle on both sides rather than on just one side, so there's no issues any more with the axle shifting from too much pushing or pulling.

Instead of using two actuators this version can do the shifting with just one actuator, which controls the two shifting arms connected to the gearboxes. I'm using a clutch gear directly on the M-motor used for shifting (not pictured in the picture above but it connects directly to the small gear on the top right). Some bits of the shifting arm have some tolerance, so that combined with the clutch gear seems to result in quite satisfying gear shifts.

Above is a picture of the latest gearbox core in yet another prototype shell. It ended up still being quite wide because I wanted to keep it modular, so I can take apart both sidewall tracks quite easily to access the gearbox core. In the end I just piled up all the non-Lego components on top in order to test it out. There's still plenty of space inside so my goal of having a flippable robot that willwork on both sides is quite attainable.

I found out that in the current setup the highest gear doesn't really work for turning, most likely because there's still a fair bit of contact area. I think I can gear it down by 1.5x/1.67x and it'll be perfect. I also need to buy a new USB battery pack, so the final design will depend a lot on the dimensions of that. I haven't decided yet which one. More to come much later because I'm off cycling from next week!

Still to do:

  • Fix the gearing.
  • Make it lower.
  • Get better USB battery that allows for more amps.
  • Buy UPS circuit so I can build a charging station.
  • Hook up the Raspberry Pi camera, camera motor and lights.
  • Decrease track contact surface with ground if possible.
  • Build internal compartments for the electronics and the battery.

Posted in Tech | Tagged , , ,

Raspberry Pi controlled Lego car part 2

Not many pictures this time, because unlike last time I'll rant a bit this time about getting the software on the Pi working. To start off: I did something rather stupid: I updated Raspbian. It took ages to update the OS and all the packages. The Pi isn't very fast for that. I should've just downloaded a new image. Here's how I lost a lot of time.

After updating the OS my wifi stopped working. I'm using a small TP-link USB wifi, since my Raspberry Pi B+ doesn't come with on-board wifi. I did a lot of searching on why this would suddenly stop working, and found that, only in some cases, the B+ is incapable of providing enough power to the USB ports to make my particular model of wifi adapter work. The wifi did in fact work for just a split second after booting, and I was able to ping the Pi from another PC, but it almost immediately disappeared again. This I thought was a good indication that it was indeed a power issue.

I bought a USB cable from Amazon that combines two USB plugs, one for data, one for power, into one output, for the wifi plug. I was fairly confident that this would solve my problem. First I plugged both inputs into the Pi's USB ports, but no luck. Then I tried plugging the USB power input directly into my USB battery pack, but that didn't work either. It did have a weird side effect, in that if I disconnect the Pi's regular micro-USB power connector, it miraculously stays powered through the USB wifi plug. Weird, but not useful.

So I did some more digging and eventually found out that for every Pi kernel you need to manually (re)compile your wifi plug's driver. Ugh. I got started on doing that but it took ages. I eventually managed to find a site that offered precompiled drivers and simple installation instructions. Not exactly open-source but I'm definitely not going to wait hours for the bloody thing to compile.

With the wifi fixed and the motors super-easy to control via the Python GPIO library, I got to work on getting the Pi's camera feed to work. The Pi supposedly does full-HD video capture at decent framerates so I had high hopes of getting a nice stream going. Unrealistically high hopes, it turned out. Recording decent quality video is one thing, but streaming it in real-time with little enough delay to control a moving vehicle, that's quite another. I had to turn down the resolution all the way back to 640x480 to get <500ms delay, but after that it's quite usable. The uv4l raspicam package comes with a built-in server to stream video, which is actually pretty nice when playing around with it on the local network, but since my final goal is to open it up to the internet I'll have to find something a lot more secure than that. I'll likely set up a separate Python server to forward the video feed, or stream it from the device directly. I hope it won't introduce too much extra delay..

On the hardware front I'm playing around with some of Sariel's gearboxes. I bought a set of various Lego gears on ebay since my aging Lego Technic did not have many useful parts. I built this three-speed gearbox and then figured I might as well buy the Lego Servo motor as well to play around with.

Turns out that controlling a servo motor from the Pi is a lot more difficult than controlling a regular motor. To get the servo motor to go to a pre-set position you need to use pulse width modulation with a very specific duty cycle for each position. If you get the duty cycle slightly wrong the servo will jitter around the position and move back and forth a bit. The same happens when using the Python GPIO default module, which comes PWM functionality built-in, but just can't be real-time enough to generate a stable signal. There's loads of jitter if you try it that way. I ended up going with RPIO, which uses Direct Memory Access to get the timings right. I played with it for hours but in the end still could only get about half out of the supposed 14 positions to select correctly. I think that's more of a problem on my side though, and I'm probably using the wrong duty cycles or frequencies. That said, I'm totally indulging at this point because the gearbox only needed the off position and full negative and positive duty cycles, so I didn't even need to use pulse width modulation at all. It was an interesting side track though.

Once I got the three-speed gearbox working with the servo I slapped an XL motor on to it and immediately realized that this gearbox design will never work for my tracked vehicle. As soon as I applied only a little pressure on the output wheel the servo axle would fail and start rotating. It really doesn't stand up very well to any decent amount of torque. Time for another design. I ended with a super-simple custom design for a 2-speed gearbox that I got off the internet, but all the simple designs, the designs that I actually have the parts for to build, don't seem to be meant to be controlled with the servo motor. I played around with this for quite some time last Sunday and eventually managed to rig up some kind of controlling arm to push and pull the middle axle of the gearbox so it can shift gears. I haven't tested this with load, though, so I'm not sure if it'll hold up very well in the final vehicle. But I'm a bit more confident about it than I was about the three-speed servo gearbox.

The next challenge will be to duplicate the gearbox and make a design that allows the servo to change gears in both gearboxes simultaneously. Since I'm making a vehicle with independently-controlled caterpillar tracks (but only have one servo motor) I'll need to have one gearbox for each track.

Lastly, I got one more thing wrong in the last post, about getting power to the motors. I had bought a USB-to-9V cable, which I thought didn't work in my USB battery pack because the battery pack was smart enough to disable the port if it detected that no power was being drawn. That assumption turned out to be completely wrong. Instead, what happened was that the cable had a very shitty USB connector and after I let go of the connector it would drop a bit and disconnect. I duct-taped it into place and it works perfectly, so I can get away with using just one USB battery pack (with two USB ports) for my vehicle. Yay!

Posted in Tech | Tagged , , ,

Raspberry Pi controlled Lego car part 1

So, I have a fair bit of Lego lying around from my childhood days. Not a lot of technical parts, but enough to have some fun with. I also have a Raspberry Pi lying around after a failed experiment where I tried to use it as a security camera. Why not combine the two? I figured I could build a Lego car that I can control remotely via a little server on the Raspberry Pi, which would also stream its camera feed. It seemed easy enough, especially after discovering a page that explained exactly how to make the hardware part of it work. Never did I imagine it would take this much work to get it up and running..

This post will detail the hardware iterations and setbacks I faced. The next post will go into detail about the software side of things.

So, before starting on this project, here is the list of things I thought I'd need to make this work:

  • Bunch of Lego: wheels, gears, other technic parts and some generic bricks to connect it all up. (already owned)
  • Raspberry Pi plus camera module. (already owned)
  • A USB battery pack (already owned)
  • Two Lego power functions motors.
  • A 9 volt battery.
  • A motor controller.
  • Some Dupont wires to connect it all up.

Version 1

I bought the M motor starter kit and a separate M motor for my first iteration. I built a very nifty motor assembly and a very strong shell structure to house the components. Here's how it looked like:

v1.0

It is thus that I found out that I should never overengineer before testing. While building the thing I discovered that I didn't have the parts required to drive all six wheels, so I chose to just drive the middle wheels instead. I figured that by gearing down a bit it should be fine. Much nope. The M motors were way too weak to power the construction, which was already quite heavy from the USB battery pack, but weighed down even more because of its overengineered sturdiness. Having just the center wheels powered was also a terrible decision. Fail.

Version 2

v2.0

I built this is a test version to experiment with gear ratios and to see if in a lighter version the M motors would have enough power to drive the car. Answer: not really. I got it to go forward and backward pretty decently, but I still didn't have the parts required to power all the wheels, so the motors were not strong enough to turn the whole thing without a steering assembly. Fail again.

So I had two options at this point. Option one was to build a rack-and-pinion steering assembly, for which I had the parts available and did end up experiment with, but in the end I wasn't happy with its turning radius and how I'd either have to buy a servo motor or have an 'unclean' solution with a clutch gear to handle the stopping at the end of the wheel turning axis.

Instead, I went with option two: throw more money at it. I bought two XL motors and a crapload of caterpillar tracks. That'll give me the power and the grip I need to build something really nice.

Version 3

..or not. It does look impressive though. Here's a test build with the power functions battery box instead of the external 9 volt battery.

v3.0-test

At this point I was still powering the motors via a separate 9 volt battery. I figured that, since my USB battery had two USB connectors, I could use it to power the motors as well, so I ordered a USB-to-9-volt cable from Amazon. That should help me save some weight by not having to put in two batteries. Sadly, this did not go well.

USB batteries are pretty smart. So smart in fact, that they only output power if they think something's plugged in. The USB-to-9-volt cable worked fine on a powered usb hub, but every time I'd try to hook it up between the battery and the motor controller it would simply not turn on. Crap.

I found another USB battery, which is actually a battery used for starting cars that happens to have a USB port on it. This one did always keep the power on if I plugged in the USB-to-9V cable. Good! Except it only had one USB port, so I couldn't also power the Raspberry Pi from it. So I ended up with two USB batteries and over double the original weight..

v3.0-final

The big green thing is the car-charging battery. Even without the second battery the 3:1 gearing wasn't quite powerful enough to rotate this monstrosity when on certain surfaces, such as medium-thick carpet. Once again, fail. And once again, I spent way too much time overengineering the construction without testing it first with its full weight.

Version 3.5

I figured I'd try to keep the next version as small and light as possible and worry about motor powering and recharging issues later. I managed to build a pretty small prototype.

v3.5-test

Now, I had one option left to avoid the use of two batteries. The big green car charger battery did, in addition to its one USB port, come with a 12V output. It's not the 9 volts that the Lego motors need, but I did find at least one link claiming that the motors should run fine on 12 volts as well. I had previously done this as a child when connecting an old technic 9V motor to my 12V Lego train controller, which gave it quite a nice speed boost as well. I figured this would be an acceptable trick. I butchered an old power supply, cut off it's circular connector and used it to connect up the green battery's 12V port up to the motor connector.

To avoid any more gearing issues I added another axis, bringing the final ratio down to 9:1. The build ended up much larger than I had intended, but still smaller than v3.0. With better gear ratios and a higher voltage to the motors.

v3.5-final

You may notice the second battery sticking out at the end of this bulky thing, despite the fact that the green battery has a free USB port thanks to the makeshift 12V connector. This is because the stupid battery doesn't let you use both outputs at once. It just turns off one or the other. Not ideal!

I'm still annoyed at this but don't have an immediate solution. The reason I spent so much effort trying to get everything onto one battery was because I intended to build a little wall charging station, so I can drive the robot into the charging station, which will connect the charging port of the USB battery onto a USB wall socket. I gave this a try with the double-ported battery while the Raspberry Pi was connected, and sadly it resets the Pi as soon as the charging connector is plugged in. Crap times two. I haven't tried this trick with the green battery, but that's pointless anyway since it only lets you use one device at a time. Looks like I won't be able to charge the thing remotely while it's running.

V3.5 still has a whole bunch of issues. It works great in terms of motor and track performance though. It moves and turns fantastically. even loaded with two bulky batteries. The motor placement isn't great though; they're way too close to the ground. I need to fix that in the next version. It's also longer and wider than it needs to be. Once I get a solution to the two-batteries issue I'll decide on how large the next version will be. I'm also thinking about buying the servo motor and using it to power a small gearbox, but I'd also need to buy more technic gears and axles for that, and I've kind of already spent way more on this project than I thought I would spend..

For now though, I'll stick with this hardware design and focus on getting the software up and running. More on that next time.

 

Posted in Tech | Tagged ,

New hobby project

Turns out it's really easy to control Lego power functions motors via a Raspberry Pi. I found myself a new hobby project :)

2017-01-08 20.24.33

Posted in Tech | Tagged ,