https://lhexapod.com/ Recent content in Home on L'Hexapod Hugo -- gohugo.io en-uk Mon, 06 Mar 2023 00:00:00 +0000 https://lhexapod.com/blog/2023/03/delays.html Mon, 06 Mar 2023 00:00:00 +0000 https://lhexapod.com/blog/2023/03/delays.html Back in 2010 I thought that the birth of my first son, Scott, would be just a small blip in my journey into robotics but, looking back, it seems to have been the end of that chapter. Of course, raising children takes time, and Scott was just the first; he was followed shortly after by Max and if I thought assembly and robotics was complex to learn it’s nothing compared to raising kids! https://lhexapod.com/blog/2010/02/delays.html Tue, 16 Feb 2010 00:00:00 +0000 https://lhexapod.com/blog/2010/02/delays.html I’ve been very busy with other things just recently and so I haven’t been able to spend much time on this project. Work has been busy as I’m working towards a new release of my code and my son Scott was born on 25th January. Right now I have very little spare time for my robotics but I’m sure that will change as things settle into a new routine. https://lhexapod.com/blog/2010/01/bug-in-v70-of-the-servo-controller-firmware.html Sun, 03 Jan 2010 00:00:00 +0000 https://lhexapod.com/blog/2010/01/bug-in-v70-of-the-servo-controller-firmware.html The simple servo sequencer that I’ve been working on has exposed a bug in the servo controller firmware. The bug is due to stack corruption during movement completion notifications, so it only happens if you use the ‘multi-move’ commands or the delay move command. The problem is that at the end of SerialSendMoveCompletionNotification we jump back to the serial data accumulation loop rather than using a ret to return… Since we enter SerialSendMoveCompletionNotification via a call rather than a jump we are failing to balance the stack and so eating two bytes each time we call the function. https://lhexapod.com/blog/2010/01/where-are-we.html Sat, 02 Jan 2010 00:00:00 +0000 https://lhexapod.com/blog/2010/01/where-are-we.html Once the servo controller code was feature complete I switched to looking at the hardware side of things and thinking about the next stage, the servo sequencing. From a hardware point of view I had several things to work on. Firstly I needed to get the servo controller and I/O multiplexor chips off of a breadboard and onto something a little more permanent. Since I still find building things with perfboard a little hard I decided to build the controller itself on one board and build separate daughter boards for the I/O multiplexing. https://lhexapod.com/blog/2009/12/sensing-servo-torque.html Mon, 07 Dec 2009 08:34:04 +0000 https://lhexapod.com/blog/2009/12/sensing-servo-torque.html Whilst playing around with my servo controller I realised that the power used by a servo goes up considerably when it’s under heavy load (such as when it’s pressing against the table and still trying to move). I can, potentially, get an idea of this load by measuring the current that each servo is using and using this feedback somehow. I’ve yet to work out how, but at the very least it could be used to protect the servos against overloading; if the load gets above a certain threshold then stop moving! https://lhexapod.com/blog/2009/12/new-soldering-iron.html Thu, 03 Dec 2009 10:32:45 +0000 https://lhexapod.com/blog/2009/12/new-soldering-iron.html I decided to treat myself to an early christmas present and bought a 60W temperature controlled soldering station (a ZD-916 which I got from Maplin). All I can say is WOW. Suddenly I can solder neatly rather than making a smeary mess. The difference between this and my cheapo 12W soldering iron is just unbelievable. It just makes the whole process SO much easier. Where in the past when soldering something with a large heat sink or onto a large pad would be painful as both items would never seem to get up to temperature now I hear the iron click on as I touch the items to be soldered and the heat stays constant and it just works… Highly recommended. https://lhexapod.com/blog/2009/11/atmega168-64-channel-servo-controller-with-advanced-servo-commands.html Sun, 29 Nov 2009 19:51:15 +0000 https://lhexapod.com/blog/2009/11/atmega168-64-channel-servo-controller-with-advanced-servo-commands.html This is the AVR Studio project and assembly language source code files for the latest version (v7.0) of my 64 channel serial servo controller. This is the latest version of the ATMega168 version of the code which includes all of the new servo commands that I wrote about here including the multi-move command and the unit tests that I spoke of here. The controller allows you to set minimum, maximum and startup servo positions for each servo which can be saved into eeprom and used every time the controller is powered up. https://lhexapod.com/blog/2009/11/back-to-jit-testing.html Thu, 26 Nov 2009 12:41:16 +0000 https://lhexapod.com/blog/2009/11/back-to-jit-testing.html The latest version of the serial servo controller is now fully operational (I’ll upload the source code shortly). There are still some bugs that I’m finding but the work I put in to getting the unit tests in place makes fixing these bugs pretty straight forward. Whilst I have pretty much 100% coverage for the simpler serial commands I’ve stopped writing tests for the ‘multi-move’ command now and I’ve switched to “Just in time” testing; that is I write a test in response to finding a bug. https://lhexapod.com/blog/2009/11/testing-backwards.html Mon, 16 Nov 2009 16:48:31 +0000 https://lhexapod.com/blog/2009/11/testing-backwards.html It’s taken me almost a month but I’m finally back to working on integrating the multiple servo move command into the rest of the code. Well, the integration was done long ago, unfortunately the debugging was the bit that was taking up my time. I decided that putting ‘printf’ style debug output into the routine to attempt to debug it from my PC based control software was just the wrong way to go about finding the problems and so I set off on a mission to finally get some unit testing into my code. https://lhexapod.com/blog/2009/11/chiphackercom.html Sun, 15 Nov 2009 10:08:16 +0000 https://lhexapod.com/blog/2009/11/chiphackercom.html For those of you interested in the kind of thing that this blog is about you might also find ChipHacker.com useful. It’s a ‘stackoverflow’ for embedded programming and electronics people. Hopefully it will become a useful resource! https://lhexapod.com/blog/2009/11/relative-branch-out-of-reach.html Sat, 14 Nov 2009 15:09:51 +0000 https://lhexapod.com/blog/2009/11/relative-branch-out-of-reach.html The test code for the serial command processing code for my serial servo controller is turning out to be the largest piece of assembly language that I’ve written. This means that all of a sudden I’m coming across “Relative branch out of reach” errors during the compile. I’ve got to a point where every time I add a test I have shuffled the code to such an extent that several relative branches need adjusting from rjmp to jmp or rcall to call. https://lhexapod.com/blog/2009/10/testing-testing.html Sat, 31 Oct 2009 12:53:47 +0000 https://lhexapod.com/blog/2009/10/testing-testing.html The AVR assembly language unit tests that I spoke of last week are going well. I decided to explore the idea of unit testing by writing tests for the easier to test aspects of the serial protocol code and then, as this went well, I decided to write tests for the serial protocol code in order rather that simply jumping to write tests for the code that I know is broken. https://lhexapod.com/blog/2009/10/repeatable-unit-testing-with-avr-assembler-and-avr-studio.html Thu, 22 Oct 2009 15:49:09 +0000 https://lhexapod.com/blog/2009/10/repeatable-unit-testing-with-avr-assembler-and-avr-studio.html As I mentioned yesterday the servo controller project has got to the point where being able to unit test the code would be useful to me. In my day job as a C++ server developer I’ve been using unit tests for several years and most of the code that I write is written in a Test Driven Development style. This works well for me and was one of the first things that I missed when I started to develop in AVR assembler in AVR Studio. https://lhexapod.com/blog/2009/10/unit-testing-avr-assembly-language.html Wed, 21 Oct 2009 16:24:55 +0000 https://lhexapod.com/blog/2009/10/unit-testing-avr-assembly-language.html Way back at the beginning of this journey I mentioned the fact that I’d quite like to be able to use some of the development disciplines that I use in my day job during the development of the firmware for my hexapod. Now that I’ve actually written some non trivial assembly language for the AVR I find that I’m missing not having my usual unit tests to support my ongoing development and refactoring. https://lhexapod.com/blog/2009/10/integrating-the-multi-move-command.html Thu, 15 Oct 2009 21:26:11 +0000 https://lhexapod.com/blog/2009/10/integrating-the-multi-move-command.html I’m in the process of integrating the stand alone code that implements my ‘multi-servo move’ command and the rest of the controller. It’s harder than it should be, probably because I’m not experienced enough yet with assembly language not to have made some school boy errors. Once again I’ve run out of registers, mainly because I’m trying not to have to push stuff on the stack that often. I’ve been juggling with the limited number of registers and up until now it’s worked but… https://lhexapod.com/blog/2009/10/after-the-servo-controller.html Sun, 11 Oct 2009 19:47:14 +0000 https://lhexapod.com/blog/2009/10/after-the-servo-controller.html The work on turning my excel spreadsheet into AVR assembler code which can move multiple servos to arrive at their target locations at the same time is proceeding well. I have the required code operating in a stand alone environment in the simulator and all I need to do now is merge that in with the rest of the code… Once that’s done my servo controller is complete and whilst I already know that there are at least two further versions in the pipeline I expect I’ll move onto something more before working on them. https://lhexapod.com/blog/2009/10/moving-multiple-servos-at-once.html Wed, 07 Oct 2009 12:42:57 +0000 https://lhexapod.com/blog/2009/10/moving-multiple-servos-at-once.html The final command for my serial servo controller is the most complex. The idea behind it is that with a hexapod leg you will want to be able to move the leg to a new position where the new position requires all three of the servos that manage the leg to move to potentially new locations. Ideally you want the “foot” to arrive at the final resting place in such a way that all of the servos complete their moves at the same time. https://lhexapod.com/blog/2009/10/almost-there.html Mon, 05 Oct 2009 22:13:06 +0000 https://lhexapod.com/blog/2009/10/almost-there.html Work on the latest version of the serial servo controller is going well. I’d accumulated a pile of random nice to have ideas, some of which then necessitated some other ideas, and then there was the one must have command (the one which moves several servos to new positions over time and ensures that they all arrive at their final resting places at the same time). Of course I’ve worked on some of the nice to haves rather than dealing with the final ‘must have’ command that I need before I can move on to writing some gait controlling software to move multiple legs in sequence… https://lhexapod.com/blog/2009/10/new-design-please.html Sat, 03 Oct 2009 22:21:59 +0000 https://lhexapod.com/blog/2009/10/new-design-please.html Having discussed my serial communication issues on AVRFreaks I’ve decided that I need a new design for the servo controller. My current design is very successful in doing what I set out to do, which was to give priority to the PWM generation aspect of the code. We’re generating a rock solid PWM signal. Unfortunately this is at the expense of the correctness of the serial communications and that just isn’t right (although the original code had these same serial comms problems too! https://lhexapod.com/blog/2009/10/flow-control-is-the-key.html Fri, 02 Oct 2009 14:59:19 +0000 https://lhexapod.com/blog/2009/10/flow-control-is-the-key.html I posted a question about my serial communications issues over on AVRFreaks and so far the answers have been pointing in the direction of including some form of formalised flow control. This makes sense. I’ve yet to decide if hardware flow control in a RTS/CTS form or software flow control such as Xon/Xoff would be best… https://lhexapod.com/blog/2009/10/serial-communications-issues.html Fri, 02 Oct 2009 10:53:56 +0000 https://lhexapod.com/blog/2009/10/serial-communications-issues.html I’ve just spent a while tracking down a but which ended up being in my PC based control software rather than in the serial servo controller firmware. The symptoms of the problem were that my servo controller would suddenly to process random, poorly formed commands. My control software was sending commands correctly but it wasn’t waiting for a command echo from the servo controller before sending the next command. Due to the design of the controller (i. https://lhexapod.com/blog/2009/10/i-seem-to-have-developed-something-remarkably-similar-to-the-ssc-32.html Thu, 01 Oct 2009 09:45:18 +0000 https://lhexapod.com/blog/2009/10/i-seem-to-have-developed-something-remarkably-similar-to-the-ssc-32.html I was looking for information to help me decide which servos to buy for the legs; wondering about torque and cost and whatever when I followed a link to the Lynxmotion site and came across the documentation for their SSC 32 servo controller. Although I’d looked at their PC based control software that drives this servo controller I hadn’t seen the docs for the controller itself. It seems that it has most of the features that my controller has, including the ‘move multiple servos so that they get to the end at the same time’ command that I’m working on now. https://lhexapod.com/blog/2009/09/storing-data-in-the-eeprom-of-an-atmega168.html Wed, 30 Sep 2009 08:14:24 +0000 https://lhexapod.com/blog/2009/09/storing-data-in-the-eeprom-of-an-atmega168.html Some of the new commands that I have planned for the servo controller will require that I load and save persistent settings from the ATMega’s eeprom. Having spent a little time looking at the example code in the datasheets it seems that you have to disable interrupts to safely read and write the eeprom. It’s not a problem to have interrupts disabled whilst I read the settings when the processor boots up but allowing new values to be written back to the eeprom as the result of a serial command will be problematic given the interrupt driven nature of our PWM pulse train. https://lhexapod.com/blog/2009/09/atmega168-64-channel-servo-controller.html Tue, 29 Sep 2009 09:01:16 +0000 https://lhexapod.com/blog/2009/09/atmega168-64-channel-servo-controller.html This is the source code for the latest version of the 64 channel servo controller as detailed here. This is an ATMega168 version of the controller that was originally developed for the ATtiny2313 but which was ported to the ATMega when I ran out of memory on the ATtiny. The schematic required is similar to the one for the ATtiny2313, I’ll produce a new one for the ATMega168 when I get some time. https://lhexapod.com/blog/2009/09/new-servo-controller-commands.html Thu, 24 Sep 2009 16:28:38 +0000 https://lhexapod.com/blog/2009/09/new-servo-controller-commands.html The new 64 channel ATMega168 serial servo controller accepts the following commands. All successful commands are echoed back. Parameters are validated and errors are indicated with an error response of [0xFF] [badParamIndex] [Command echo] where badParamIndex is a 1 based index of the parameters in the command and indicates which parameter failed validation. Set Servo Position [0x41] [servo] [position] - This command operates in the same way as the standard SSC compatible servo command that the original servo controllers supported. https://lhexapod.com/blog/2009/09/moving-forward.html Tue, 22 Sep 2009 08:50:40 +0000 https://lhexapod.com/blog/2009/09/moving-forward.html Due to work pressure and then holidays and then more work pressure I had to take a break from the servo controller for a couple of weeks. Most of the code changes that I had previously been discussing have been implemented and I’m now in the process of testing an ATMega168 version of the 64 channel servo controller complete with new style commands! Since this version of the servo controller uses a custom serial protocol and since it can send unsolicited serial responses back to its controller I needed to write a new PC based control program to test it with. https://lhexapod.com/blog/2009/08/prototype-fabrication.html Sat, 08 Aug 2009 14:12:41 +0000 https://lhexapod.com/blog/2009/08/prototype-fabrication.html As I mentioned back in April after I’d put together my first prototype leg, “the prototype leg has some fairly major failings from a mechanical point of view”. Ideally the real legs will be designed and cut from sheet material, either plastic or metal. Getting to that point is going to take some time though and right now I haven’t been able to locate a UK based laser cutting service at an affordable price. https://lhexapod.com/blog/2009/08/and-then-switch-to-the-atmega168.html Fri, 07 Aug 2009 08:48:26 +0000 https://lhexapod.com/blog/2009/08/and-then-switch-to-the-atmega168.html The new functionality in my servo control takes more memory to implement due to the more complex state that we need to maintain for each servo. The simple controller could support up to 64 PWM channels on the ATTiny2313, the more advanced controller can, at the present stage of the design, support around 15. There’s scope to optimise the storage of the expanded 2 byte pulse duration values; they’re 12 bit values and so will fit in 1. https://lhexapod.com/blog/2009/08/registers-stack-usage-and-timing.html Thu, 06 Aug 2009 08:22:13 +0000 https://lhexapod.com/blog/2009/08/registers-stack-usage-and-timing.html So far the servo controller development has been reasonably straight forward; once various design issues were considered and once I’d got my head around building the hardware and learning AVR assembly language. However I expect that my assembly code has many novice mistakes and that it’s probably not especially idiomatic. I haven’t been writing in the language long enough and I haven’t read enough of other people’s code for it to be otherwise. https://lhexapod.com/blog/2009/08/asynchronous-serial-responses.html Wed, 05 Aug 2009 09:36:03 +0000 https://lhexapod.com/blog/2009/08/asynchronous-serial-responses.html Part of the new functionality that I’m developing for the serial servo controller for my hexapod robot is for the servo controller to take its time in moving a servo from where it is at the moment to where I want it to be. The idea being that the servo controller can worry about the required pacing of the servo moves and we can ‘step’ from the current position to the required position automatically within the servo controller. https://lhexapod.com/blog/2009/08/all-the-problems-of-multi-threading-without-the-threads.html Tue, 04 Aug 2009 09:54:05 +0000 https://lhexapod.com/blog/2009/08/all-the-problems-of-multi-threading-without-the-threads.html One of the problems of moving from the simple three byte SSC style control system to a system where we can do clever things with multiple servos at once is that the data required to do these clever things is bigger than the data required to do the simple things. See here for the details of the new control data structure. The problem with data that is bigger is reading or writing it atomically (that is, ensuring that our multi-byte data structures are in a consistent state at all times). https://lhexapod.com/blog/2009/08/extending-the-servo-controller.html Mon, 03 Aug 2009 13:20:38 +0000 https://lhexapod.com/blog/2009/08/extending-the-servo-controller.html To be able to implement the new commands for the servo controller I need to adjust the data that we use to control the servos. Right now we have a single byte per servo and that byte contains a value between 0 and 254 which represents the length of the pulse sent to the servo. To be able to implement the delayed or progressive move command we’ll need to know the current servo position and the desired servo position. https://lhexapod.com/blog/2009/08/whats-next.html Mon, 03 Aug 2009 09:49:05 +0000 https://lhexapod.com/blog/2009/08/whats-next.html I now have an easy to extend PWM servo controller and the next job on my list of things to do is extend it so that it supports the functionality that I feel I need for correct control of my hexapod’s legs. As I mentioned here, I’d like to be able to tell the servo controller to move a group of servos to a particular set of positions so that they all arrive at the same time and, the movement is incremental and the movement can be stopped at any point in case a leg sensor detects an obstruction. https://lhexapod.com/blog/2009/08/tweaking-the-servo-controller.html Sun, 02 Aug 2009 09:15:10 +0000 https://lhexapod.com/blog/2009/08/tweaking-the-servo-controller.html The 64 channel serial servo controller that I’ve been developing works pretty well for me but most of my development and testing was done in the AVR studio simulator. Once I actually started working with my hardware again I noticed a slight problem. Although my servo controller was operating to spec my spec was wrong. The problem is that the data sheet I have for the Hitec HS-422 servo states that it requires a pulse length of between 900us and 2. https://lhexapod.com/blog/2009/08/attiny2313-24-channel-servo-controller-schematic.html Sat, 01 Aug 2009 11:39:10 +0000 https://lhexapod.com/blog/2009/08/attiny2313-24-channel-servo-controller-schematic.html Here is a schematic for a 24 channel version of the ATTiny2313 servo controller. You can expand the number of channels up to the full 64 by adding additional CD74HCT238Es where each additional MUX chip is connected to the next available pin on port b. ATTiny2313-24ChannelServoController.png The schematic, in Eagle format, is here: ATTiny2313-24ChannelServoController.sch and a potential board layout is here: ATTiny2313-24ChannelServoController.brd These were produced with Eagle and I don’t think I could have worked out how to use Eagle without reading Build Your Own Printed Circuit Board by Al Williams. https://lhexapod.com/blog/2009/08/a-timer-driven-pwm-servo-controller-part-4.html Sat, 01 Aug 2009 08:12:02 +0000 https://lhexapod.com/blog/2009/08/a-timer-driven-pwm-servo-controller-part-4.html The time has finally come to put all of the code from the last three parts of this article together to form a complete serial configured, 64 channel, PWM servo controller for the ATTiny2313 and several CD74HCT238Es. Here’s a recap of where we are and how we got here: In part 1 I put together some basic PWM generation code that uses the 16-bit Timer1 to generate a rock solid PWM pulse train from some pulse duration data. https://lhexapod.com/blog/2009/07/a-timer-driven-pwm-servo-controller-part-3.html Thu, 30 Jul 2009 14:12:31 +0000 https://lhexapod.com/blog/2009/07/a-timer-driven-pwm-servo-controller-part-3.html This is part three of a series of articles about the servo controller that I’m building for use in the hexapod robot that I intend to build. The first two articles in the series have presented the timer driven PWM generation code and the code used to take the configuration data that is managed by the serial port protocol and convert it into the data that is needed by the PWM generation code. https://lhexapod.com/blog/2009/07/a-timer-driven-pwm-servo-controller-part-2.html Wed, 29 Jul 2009 11:26:50 +0000 https://lhexapod.com/blog/2009/07/a-timer-driven-pwm-servo-controller-part-2.html In part1 of this timer driven PWM servo controller I built some code which uses Timer1 in the ATTiny2313 to generate 64 PWM signals. The code in part 1 worked from hard-coded dummy data. The code presented here shows how we can create the data that the PWM generation code needs to run. The timer driven PWM code presented here works in terms of two byte pulse durations and a 1 byte value that determines which pulses are still being generated. https://lhexapod.com/blog/2009/07/a-timer-driven-pwm-servo-controller.html Tue, 28 Jul 2009 09:28:24 +0000 https://lhexapod.com/blog/2009/07/a-timer-driven-pwm-servo-controller.html As I mentioned recently, the original servo controller firmware that I posted was flawed and wasn’t suitable to use as a base for the more complex servo control code that I want to add to the controller. The new firmware follows the design that I spoke of here and relies on the ATTiny’s 16-bit timer to generate our PWM signals. Since we’re using a timer we don’t need to waste processor time with hard-coded timing loops full of ’nop’s as we did in the original firmware and this gives us much more time to do useful work. https://lhexapod.com/blog/2009/07/redesigning-the-servo-controller-firmware.html Mon, 06 Jul 2009 16:12:22 +0000 https://lhexapod.com/blog/2009/07/redesigning-the-servo-controller-firmware.html As I mentioned here, there’s a fundamental design problem with the two versions of the ATTiny2313 servo controller firmware that I’ve presented so far (see the 8 channel source code and the 64 channel source code). The timing that determines the shape of the PWM signals that are generated relies on carefully crafted timing loops and the time taken by particular code sequences and this is affected by the interrupt driven serial I/O that is used to control the controller. https://lhexapod.com/blog/2009/06/chiara-hexapod.html Wed, 17 Jun 2009 18:06:51 +0000 https://lhexapod.com/blog/2009/06/chiara-hexapod.html This is rather nice; Chiara Robot from Carnegie Mellon University’s Tekkotsu lab (via HackedGadgets.com). https://lhexapod.com/blog/2009/06/fabrication.html Wed, 10 Jun 2009 12:14:58 +0000 https://lhexapod.com/blog/2009/06/fabrication.html Here are some links that may help once I move onto fabricating the various pieces required to build the hexapod’s body. This is a simple 4 legged walking robot that was machined from an A4 piece of 4mm ply wood. This is the guy’s website, with more details of how he produced the robot. And this is the Dutch prototyping lab that he used to laser cut the pieces. Finally, this is an interesting link to David Buckley’s walking robots page. https://lhexapod.com/blog/2009/06/linkfest.html Fri, 05 Jun 2009 18:32:55 +0000 https://lhexapod.com/blog/2009/06/linkfest.html A collection of links that I’ve been using recently for research. Servos and robotics Hitec HS-422 Servo. The servos I currently have; likely not suitable for use as actual leg servos due to lack of torque. Useful link as www.superdroidrobots.com has links to the spec sheet for the servo and a selection of different spec servos with corresponding prices. More useful to me than the actual Hitec website as that doesn’t list relative prices. https://lhexapod.com/blog/2009/06/fundamental-design-flaw-in-the-servo-controller-code.html Wed, 03 Jun 2009 18:02:01 +0000 https://lhexapod.com/blog/2009/06/fundamental-design-flaw-in-the-servo-controller-code.html In my opinion there’s a fundamental design flaw in the both the 8 channel and the 64 channel servo controller firmware that I’ve presented. Both allow the serial data handling code to take priority over the PWM generation code. This means that there is no way to guarantee that the PWM generation code will produce a perfect pulse train in the presence of configuration changes being sent to the controller via the serial port. https://lhexapod.com/blog/2009/06/atmel-attiny2313-servo-controller-v02-source-code.html Wed, 03 Jun 2009 10:54:07 +0000 https://lhexapod.com/blog/2009/06/atmel-attiny2313-servo-controller-v02-source-code.html Here’s the source code to the 64 channel ATtiny2313 servo controller. Note that you’ll need to use up to 8 CD74HCT238E, or equivalent, demultiplexer chips and that you can adjust the number of servos that you can control in steps of 8 using as many or as few CD74HCT238E chips as you want. If you only want 8 channels then you can do this without any demultiplexer chips; see here for source code to the 8 channel version. https://lhexapod.com/blog/2009/06/64-channel-servo-controller.html Tue, 02 Jun 2009 09:13:51 +0000 https://lhexapod.com/blog/2009/06/64-channel-servo-controller.html I’ve been experimenting with the servo controller that I developed for the ATtiny2313 here and the demultiplexing chips that I mentioned here. The result is a 64 channel servo controller that seems to work pretty well. Right now I haven’t breadboarded all 64 channels, I have two of the CD74HCT238E chips connected to the ATtiny but I/O pins and he firmware would drive 8 of them if they were connected to give 64 channels. https://lhexapod.com/blog/2009/05/atmel-attiny2313-servo-controller-v01-source-code.html Thu, 21 May 2009 12:16:51 +0000 https://lhexapod.com/blog/2009/05/atmel-attiny2313-servo-controller-v01-source-code.html The jitters and general instability of the hacked together simple servo controller (see here) for the ATtiny2313 were, it seems, down to the fact that the internal clock wasn’t stable enough and this caused enough timing issues to throw the PWM off enough to jiggle the servo position around rather than hold it steady. This morning my external 4MHz crystals arrived and after changing the processor’s fuse bits to accommodate the change in clock source everything was fine and the code started behaving itself. https://lhexapod.com/blog/2009/05/cd74hct238e.html Tue, 19 May 2009 17:54:10 +0000 https://lhexapod.com/blog/2009/05/cd74hct238e.html My progress has been slow over the past couple of weeks because a) I’ve been rather busy with other things and b) an order of components has gone missing in the post. The order contains some 4mhz crystals and therefore my server controller firmware testing has been on hold as I’d like to remove the potential clock instability as a potential cause of the controller jitters before continuing my debugging. https://lhexapod.com/blog/2009/05/atmel-attiny2313-servo-controller-v01.html Fri, 08 May 2009 07:00:57 +0000 https://lhexapod.com/blog/2009/05/atmel-attiny2313-servo-controller-v01.html This morning I tested the first version of my custom servo controller. It’s currently heavily based on the source for 16 channel servo controller that I’ve mentioned before. What I did was simply adjust that source for my target processor and the fact that I’m using it with a 4Mhz internal clock rather than the more standard “RS232 baud rate friendly” 3.6864 MHz that the original code used. The main changes were to the reduce the controller from 16 channels to 8 since the ATtiny2313 doesn’t have enough pins to run 16 channels and to adjust the general setup to account for the new processor. https://lhexapod.com/blog/2009/05/avr-studio-4.html Thu, 07 May 2009 08:18:20 +0000 https://lhexapod.com/blog/2009/05/avr-studio-4.html I’ve been spending some time getting to know AVR Studio 4, especially the simulation and debugging functionality. It’s a very functional and very useful free development suite that can be downloaded from Atmel from here. As I mentioned a while back I have had a C compiler and development and programming tool chain set up for a while now but I hadn’t got around to working out how to debug the code. https://lhexapod.com/blog/2009/05/i-may-have-been-a-little-harsh.html Fri, 01 May 2009 11:11:27 +0000 https://lhexapod.com/blog/2009/05/i-may-have-been-a-little-harsh.html After a little more debugging this morning I’m coming to the conclusion that I may have been a little harsh on the Arduino’s software serial port. More when I know more, but I think it’s more of a flow control issue with my data transmission from the PC. https://lhexapod.com/blog/2009/04/arduino-multiple-serial-disappointment.html Thu, 30 Apr 2009 22:46:48 +0000 https://lhexapod.com/blog/2009/04/arduino-multiple-serial-disappointment.html Tonight I took a look at the ‘software serial’ support in the Arduino. I can’t say I’m that impressed… The Arduino has a built in hardware UART (a hardware serial port) which works as expected. It allows you to talk to external serial devices but there’s only one of it so if you want to have an external device talk to you via a serial port and then you want to talk to something else via another serial port then you’re out of luck. https://lhexapod.com/blog/2009/04/the-servo-controller-problems-werent-power-supply-noise.html Thu, 30 Apr 2009 19:57:48 +0000 https://lhexapod.com/blog/2009/04/the-servo-controller-problems-werent-power-supply-noise.html I’ve been testing the new leg with one power supply for the servos and one for the electronics and all is working well. I expect that all would be working well if I were using a single power supply for both, as long as I was using the new one I soldered up and not the old one… I decided that since I would be using a 5v power supply for most of the bits of this project that I’d grab and old mains transformer and wire up a 5v regulator and run from the mains rather than batteries. https://lhexapod.com/blog/2009/04/books-for-programming-an-avr-micro.html Sat, 25 Apr 2009 22:57:49 +0000 https://lhexapod.com/blog/2009/04/books-for-programming-an-avr-micro.html So far I’ve bought three AVR programming books. AVR: An Introductory Course, Programming and Customizing the AVR Microcontroller and Atmel AVR Microcontroller Primer: Programming and Interfacing (Synthesis Lectures on Digital Circuits and Systems). They are three quite different books and each has a distinct focus. I read AVR: An Introductory Course first. It’s a slim volume that teaches you how to program the AVR family of micros with assembly language. It’s a good book and the focus is very much on learning how to program the various facilities available and how to use the various programming constructs to get work done. https://lhexapod.com/blog/2009/04/once-more-with-feeling.html Sat, 25 Apr 2009 15:58:17 +0000 https://lhexapod.com/blog/2009/04/once-more-with-feeling.html Having decided that the graduated servo positioning method was the way to go to allow for leg sensors to work correctly I started thinking about leg sensors. Here’s a new lower leg with three switches, one on the foot, one to the inside of the leg and one to the outside of the leg. ProtoLegv02-1.png ProtoLegv02-2.png Ideally the front and back switches would be extended with thin metal bars running the length of the leg and fixed just above the ankle. https://lhexapod.com/blog/2009/04/more-thoughts-on-the-proto-leg.html Thu, 23 Apr 2009 19:05:26 +0000 https://lhexapod.com/blog/2009/04/more-thoughts-on-the-proto-leg.html I adjusted my quick and dirty servo controller program to calculate the number of moves required for the servo that needed to move furthest and then spread the movement of the other servos across the same number of moves. So, given that the servo controller works in terms on a position from 0 - 254 where 0 is full left and 254 is full right and we have three servos that make up the leg I look at the differences between where the three servos are now and where they will be at the end of the move and then build a sequence of moves to get from here to there. https://lhexapod.com/blog/2009/04/first-steps-in-embedded-programming-first-build-the-hardware.html Thu, 23 Apr 2009 18:37:41 +0000 https://lhexapod.com/blog/2009/04/first-steps-in-embedded-programming-first-build-the-hardware.html This week I managed to scrape together some time to play with some of the non prototype bits and pieces that I purchased for this project. First off was breadboarding a MAX232 chip so that I could talk via my PCs serial port to my ATtiny2313 microcontroller. The MAX232 does the required level shifting and talks RS232 signals on one side and TTL signals on the other. The result is that it makes it possible to connect a microcontroller’s internal UART to a PC. https://lhexapod.com/blog/2009/04/thoughts-on-the-proto-leg.html Tue, 21 Apr 2009 13:30:10 +0000 https://lhexapod.com/blog/2009/04/thoughts-on-the-proto-leg.html The prototype leg has some fairly major failings from a mechanical point of view. The only part that may eventually find its way into a weight bearing leg is the lower leg where the cut out around the knee servo provides ample support for the servo itself and also a suitable mounting point for the servo. The hip servos need much more support before they could be used to form a weight bearing leg either in the form of metal brackets or more complexly cut board. https://lhexapod.com/blog/2009/04/prototype-leg-v01.html Mon, 20 Apr 2009 17:02:54 +0000 https://lhexapod.com/blog/2009/04/prototype-leg-v01.html I spent a little time at the weekend putting together my three servos into a prototype leg. The idea is that this very quick and very dirty little experiment should give me some more avenues to explore; and something to show people. I had originally planned to build the leg out of wood, perhaps thin plywood, but I didn’t have any laying around so instead I used some plastic window board which is relatively light and strong. https://lhexapod.com/blog/2009/04/the-servos-are-twitching.html Thu, 16 Apr 2009 14:22:13 +0000 https://lhexapod.com/blog/2009/04/the-servos-are-twitching.html My package from Cool Components arrived this morning. My choice of prototyping equipment was quickly validated when I plugged together the Arduino and the Pololu servo controller board, plugged in the servos and servo power supply, connected the lot to the pc via a usb cable and had three servos twitching back and forth under the control of the Arduino is no time. The idea is that I can now begin fabricating a leg, connect up the servos and then experiment with leg movement without needing to get the soldering iron out. https://lhexapod.com/blog/2009/04/pulse-width-modulation-for-servo-position-control.html Sat, 11 Apr 2009 00:00:00 +0000 https://lhexapod.com/blog/2009/04/pulse-width-modulation-for-servo-position-control.html First some basics: servo motors are what I’ll be using to provide movement for the robot. Each leg will consist of at least three servo motors (1 at the knee and two at the hip). As you’ll see from the wikipedia link above, servo motors are generally controlled by pulse width modulation. In order to control multiple servos you need to generate a continuous PWM control signal for each servo. https://lhexapod.com/blog/2009/04/useful-links-and-suppliers.html Thu, 09 Apr 2009 18:30:00 +0000 https://lhexapod.com/blog/2009/04/useful-links-and-suppliers.html So far most of my more interesting components have been purchased from Cool Components mainly because they’re UK based and they stocked stuff I was interested in. I found them via SparkFun which is a treasure trove of fun; unfortunately I can’t find UK distributors for much of the stuff they have available and at present I’m trying to avoid buying bits and pieces for this project from the US as the shipping is often more expensive than the order. https://lhexapod.com/blog/2009/04/servos-with-status-feedback.html Thu, 09 Apr 2009 08:10:45 +0000 https://lhexapod.com/blog/2009/04/servos-with-status-feedback.html I saw these Dynamixel DX servos mentioned on Trossen Robotics this morning, see here. They’re interesting because they have a richer interface than the normal hobby servos that I’ve been looking at and they provide a multidrop RS485 interface so that you can chain multiple servos together and control them individually via a single line. You can get feedback on the angular position, velocity and torque and also alerts if temperature and voltage deviate from expected (user specified) ranges. https://lhexapod.com/blog/2009/04/micromagic-systems.html Wed, 08 Apr 2009 16:36:18 +0000 https://lhexapod.com/blog/2009/04/micromagic-systems.html Micromagic systems do robotics and animatronics for the film and tv industry and have quite a nice selection of hexapod robots. It’s especially interesting to see the evolution of their robots here. Their latest stuff is very impressive and puts into perspective how much I have to learn… Their robotics store (http://www.hexapodrobot.com) is also full of useful information. https://lhexapod.com/blog/2009/04/a-pod-an-ant-inspired-hexapod.html Wed, 08 Apr 2009 15:24:42 +0000 https://lhexapod.com/blog/2009/04/a-pod-an-ant-inspired-hexapod.html This is the kind of thing that I mean when I say ‘hexapod robot’. I particularly like the head and mandibles. More details can be found here: http://forums.trossenrobotics.com/showthread.php?t=2762 and here: http://blog.trossenrobotics.com/index.php/2009/03/17/a-pod-a-robot-ants-tale/ https://lhexapod.com/blog/2009/04/welcome.html Wed, 08 Apr 2009 13:44:13 +0000 https://lhexapod.com/blog/2009/04/welcome.html Hi, my name is Len Holgate and this is a blog about my new project to design and build a hexapod robot; a mechanical vehicle that walks on six legs… By day I design and build high performance TCP and UDP servers for the Windows platform, my C++ technical blog is here: www.lenholgate.com. Up until a few weeks ago I’d never done any electronics or embedded programming; I decided that I needed a new hobby and so started tinkering with electronics, breadboarding and the like and, in what tends to be my typical approach to such things, I decided that the best way to push myself into this new hobby was to dive in to reasonably complex project.