UAT Robotics and Embedded Systems

Reached a max speed?

2011-12-06T11:09:00.001-07:00

So, this week's progress has been to update the software. I have gotten the software to a point, as seen in the video above, where it appears like it is running as fast as the software can go. We need to sit down and debug the system more, because clock speed settings and common sense say that we should be running it faster than it currently is doing. It is also a problem if this is running as fast as it can, because from here it can only get slower as we add more processing in the background.

I am presently thinking about moving the serial clocking out to the foreground again, having it update once with the serial buffer, and then using a boolean to track whether or not this data has already been clocked out. This would take lower precedence than incoming serial data, but it should make clocking out faster. I am wondering if, in the future, a faster board may be better, but one step at a time.

Turkey Day Rest

2011-11-29T00:22:00.001-07:00

This last week was a much needed break. I unfortunately couldn't make too much progress, but I did get a better start towards coming up with the PCB that will fit over top of the chipKIT. This needs to provide breakout jumpers for all of the panels. Since this is simply going to be headers and a couple of line drivers, it should be relatively simple. the only problem is that this board is going to cost a lot to make, since it has to at least sit over top of the chipKIT. I am designing the board to utilize more boards for expansion later, cutting down on the cost of redesign and reprinting.

I have also made some progress towards completed software. I have updated it with a new stretch of code, and have it compiled down into functions. Everything has compiled and is currently running on the chipKIT already, providing Serial feedback to ensure it's running properly. This Serial data will be removed soon when updated to a more final design in the next few days.

Software Progress

2011-11-22T00:23:00.001-07:00

The photo on the right will be explained at the end of this post. This is the culmination of a few weeks of struggle in dealing with timers.

In my time struggling and putting off in dealing with the timers, I decided to do some research on anyone else who had dealt with timers. The work that I had dine already did not reveal timers to work with interrupts. The link that I found led to this forum post. The post described someone who was using the capture and compare module, in conjunction with a timer, to invert a pin. I did some testing with the code provided, and it worked just fine. I fine tuned it to respond at a 500 kHz frequency, as seen in the bottom left corner of the display.

Now, the reason why there is a gap in the cycles is that I wanted to do a test regarding the ability to turn off and on the timer, and have it not affect the other parts. This worked beautifully, as seen in the photo above. What this means is that now I need to edit my code, with this new addition, to run the PWM cycling from the foreground to the background.

Design Changes and Milestones

2011-11-14T23:40:00.001-07:00

This week, our class is looking at milestones and how the project is coming along. It appears like our project is a bit behind schedule, but it is nothing too bad yet. Hopefully, the design change suggested by David Strait will help to improve our output of LED squares.

The improvements suggested by David offer an improvement for holding together the LEDs in the grid. In the present grid, which simply offers a hole for the LEDs to fit into, the leads are able to rotate, making the design much more of a pain to solder together. His solution is simple, redesign the left row on the soldering guide to offer grooves similar to the bending guide to hold everything down in place. As seen in the photo on the right, our 4x4 grid was cut to a 2x4 grid to help get more people working at the same time. However, the drawings that he offered me for redesign we well laid out and offer up this new idea in return: provide grooves for the LED leads to keep them from rotating around too much, and provide cut holes for open areas so that we can solder the leads together. It was a simple improvement, he put in a lot of work on this, and the design change is exactly the kind of feedback I want to hear about my designs.

More Squares!

2011-11-08T13:58:00.000-07:00

PCB minus 3 signals

To the left is the picture of the PCB in it's current state. I used FreeRouter, a plugin in KiCad that will route a PCB for you. I basically wanted this done so that I can move on to other things, so I allowed that to work it's magic. There is, however, 3 signals that still need to be routed. For some odd reason, pin 6 on all of the CD4051's are not coming through from the schematic to the PCB design, so I am still in the process of figuring out exactly what is going on with that. I have some pretty clear routes and there is still some clean up to be done to the board, but it is 95% done.

16 X 8 panel.

There has also been some progress made with the assembly of a panel. As you can see in the photo on the left, we have built a 16x8 panel. We intended to use this as a 16x7 text scroller for a competition at the school, but that never got fully completed. It did give me some insight into how much of a pain it is going to be to connect together all of the powers and grounds on a panel.

To help with progress on assembling the panel, we use the following 2 guides: a bending guide and a soldering guide.


Bending Guide.

The bending guide on the left shows the 3 stages of LED bending. The first stage, on the left, is ensuring that the LED is aligned properly. Also, one ensures that the anode of the LEDs is aligned with the bend above the LED, and all the cathodes are aligned to aim for the slots below the LED. Stage 2 (middle) shows the leads being bent in the correct orientation. The right shows the final result.


Soldering Guide

From there, 4 LEDs go into a line along the soldering guide on the right. We have found the best way to make a 4x4 grid out of one of these guides is to create 4 lines of 4 LEDs each. From there, create 2 4x2 grids of LEDs, and then solder that together.

Our goal with these guides is to create consistent 4x4 grids that we can easily and relatively quickly assemble into a 24x24 grid. We have found that in order co complete that objective this term, we need to complete 36 of these. We have 22 4x4 grids left to do.

Kinect on PC

2011-11-08T13:28:00.004-07:00

So I got the Kinect to display and track people on the monitor of a PC. Unfortunately, that wasn't my intent. What I was trying to do was to link the Kinect to my own personal computer. For some reason I was missing the mscvp100.dll file on my laptop, which didn't allow the video to show up. I'm currently working to fix the problem so that I may take my programming wherever, but for now I'll be working at UAT's Robolab.

PCB Work

2011-10-31T23:15:00.000-07:00

Current state.

Due to other time commitments, I don't have too much progress to report, but it does have a lot of pretty pictures. This picture on the right shows the current state of the PCB design for a given panel. Below is a full explanation of what all is in each portion of the design.

In addition to progress work on the PCB, it appears like the direct port writing for the software is working just fine. In dealing with software, I need to put some more time into figuring out the timers to correctly change states on the PIC on the chipKIT.

Beginning Layout.

This photo shows the planning stages of laying out the PCB. All of the components are group by type.

Design 1.

The photo to the right is the first design of the PCB. However, this seems to occupy too much space, so this design was abandoned.

Explanation.

The PCB in it's current design. It seems to occupy less space than before. Now to explain all of the parts of it:

1. Power circuit. Includes filtering capacitors, and at this point has 5V for the logic levels, a 5V high-amperage line for driving the transistors, and a 3.3V for the logic levels on the TLC5940s.

2. Jumpers to select what mode the 5940's are in. +'s are denoted for positive side of jumpers.

3. Data in and Serial Jumpers. These are configured for either the first or second board in a line-up.

4. TLC5940's and gnd side of the LEDs. This is where the magic for PWM happens for a given LED. We are planning on using more of the 14 pin ribbon cable connecting layers back to the master board to connect between the ground side of the LEDs and this panel PCB.

5. This is the power side for a line of LEDs. This uses the demuxes to select which of 24 transistors to drive a row of LEDs on the cube. Each row requires about 1.5 A; hence, high amperage traces are used.

Pink Lines:
These will have either ribbon cable headers or direct solder connections for a given panel. These will be connected to a given square of LEDs. The solder connections were used on the power side because a panel's PCB does not need to be removed easily.

Yellow lines:
The only external connections that a panel's PCB has to the outside world. It features a 14 pin ribbon cable connector for all of the data. If you have been paying attention, each panel only requires 12 data lines, the extra 2 are used to select which PCB in a 2 layer chain this board is. That is what the jumpers located in Box #3 above is used to select. There is also a power connection in the upper-right hand corner of the PCB that has a common ground, 5V logic, and 5V high amperage line.

Hopefully in the next day or 2 I should be able to finish out the PCB design.

Building the Cube

2011-10-26T11:45:00.005-07:00

Just like mentioned in the previous post, the construction of the LED cube has commenced. In 2.5 hours, we were able to solder the multi-colored LEDs in an 8 x 8 grid.

By using our bending jigs, we are able to bend the leads on the LED diodes to separate the 3 color channels from the GND (ground). The easiest way we figured for soldering the LED was with the use of a grid that we also printed in 3D as shown on the picture below.

The grid is designed to fit our LEDs with 5/8 in. distance between them. Because the size of our LED panel will be huge, we only fit up to 8 LEDs in our grid mold to easily solder small lines or squares. Once we have enough to build a 4 x 4 grid, we test them to reassure our solder was correct and no leads touch each other. Once tested we built the 8 x 8 grid and tested it again. Thankfully, we had no problems with our first grid. Several students in the Robotics Department have agreed to assist us, but to ensure nice looking, well soldered panels, Ryan and I train the students so each panel will be identical to each other.

We are still soldering the LEDs and will be posting up more pics on its build.

Progress!

2011-10-25T13:56:00.003-07:00

This last weekend we soldered together a simple little 8 X 8 grid of LEDs. This took 2-3 people, while soldering it together and checking it over, about 2.5 hours to do. This can give us a great baseline for about how long it should take us to assemble the cube. Basically, about half an hour to forty-five minutes per 4 X 4 square, including checking it over for any problem connections. Assuming that we can take the same times to produce the other 8 remaining 8 X 8 cube segments, we could be done with soldering this term's goal of a single panel in about 20 more hours. I feel like the guides printed out helped to smooth assembly along greatly, and ensure that each LED is consistent with every other one.

The above LEDs are set at 5/8" intervals, meaning that also the space between panels will need to be about 5/8". This spacing can give us an estimate that the cube of LEDs, not accounting for any of the controlling wires, will be about 15 inches on a side. Once concern with the smaller spacing is that the PCBs that I am trying to design need to be less than 5/8ths inch tall, or there will be some interference between layers. My biggest concern height-wise is the TIP31As, as these are through-hole transistors. Everything else should be fine at its current height.

I haven't made any more progress towards completing software. I know as of right now that I am getting some weird behavior regarding the GSCLK signal. I presently have a high frequency (much higher than I anticipated by a factor of 4-6) and I am not getting a consistent pulse going from 0V to 3.3V. That high frequency is something like 1.5V. I have 2 possible ideas for solutions:

Implement the timers to control when the PWM toggles on and off.
Change the writes from PORTESET to LATESET. That way I am changing the latch as opposed to the port. I am hoping that implementing this will fix the problem, but I still also do need to take care of the PWM timer as well.

I have also finished up the BoM, aside from confirming item counts. Now that I have that, I am working on trying to get the PCBs completed and sent in for manufacturing. It looks like I can fairly easily design the PCB to fit in an "L" shape, meaning that outside of the LEDs on a panel, I would only need a few inches of room to spare on a couple of sides for handling the PCB. As stated above, the TIP31A's height is a concern, and I may have top cut out a small hole in the lexan of the above layer to account for this height. I am hoping that I can get the landing holes of the transistors cut a bit wider around to accommodate for the extra width that the transistors have on part of the leads.

Initial Troubles

2011-10-19T06:02:00.002-07:00

So, I've been trying to program with openFrameworks, but before I was able to compile anything, I am greeted with an error message about missing libraries.

If you are using a Window's computer, make sure when you download Code::Blocks you choose the second download link (codeblocks-10.05mingw-setup.exe). This makes sure you download mingw along with Code::Blocks. For some reason the minimalist development environment was not properly installed on my PC. I found an easy to use installer for those who decided to not get the Code::Blocks installer with mingw.

http://tdm-gcc.tdragon.net/

After properly installing mingw, I was able to write simple C++ codes with no problem.

C++

2011-10-19T05:34:00.002-07:00

As mentioned in a previous post, openFrameworks is written in the C++ programming language. Even if you are not fluent in C++, there are several resources online for free. If you follow the setup instructions in openframeworks.cc, you'll find that they recommend installing Code::Blocks.

Code::Blocks is a cross-platform IDE (integrated development environment) that supports GCC and MSVC. User friendly, the software is easy to use and allows development for DirectX, OpenGL, and MATLAB on your Windows, Mac, or Linux PC. You may start playing with openFrameworks by following this link and follow this guide to set up your IDE.

As mentioned before, there are several resources online for C++ tutorials.

For those who like to read.
For those who like to watch.

Cube Project Work

2011-10-17T22:56:00.001-07:00

This last week has been overall an interesting week. It started off early on dealing with the bending guide prints. I originally had the bending guide print out at 10 times the size it needed because the export changed my dimensions from millimeters to centimeters. After this save option was found and changed, there were a few more iterations made on the bending guides to refine the size and ensure that the LEDs fit nicely and bend accurately.

After I got the final guide done and the prints, I began to work with the code. I struggled for a day or two with trying to figure why the schematic I had worked out correctly was not operating correctly. I did a lot of digging through the datasheets, and spent a lot of time confused as to why the signals that I thought should be operating at 5V were getting like 3.24 V. I then got an idea, borrowed someone else's chipKIT to confirm the idea, and perused the chipKIT user guides to confirm this idea. It turns out that the chipKIT operates at a 3.3V logic level, and I was expecting a 5V logic level. When providing 5V to Vcc on the TLC5940 PWM drivers, the chip then expects 0.8Vcc, or 4V, to be a high signal. Why this worked in the first video and not now I am still unsure about, but when the logic was changed around to 3.3V as opposed to 5V on Vcc, the chip worked again.

The only other problem that I am having right now, probably because of the way I am running the code right now, the LEDs are visibly flashing. It's obvious that right now the software is still too slow, so my next step with the software, after I finalize the schematics over the next few days, is to implement the interrupts and times so that data is bit banged out and the PWM cycles as fast as I think it can.

Schematics!

2011-10-11T23:11:00.000-07:00

This last week I put a lot of effort into finalizing the schematics and ensuring that the board will work the way that we want them to perform. Here's a couple of photos of the full schematics.

Master schematic, which shows connections between the chipKIT and all of the layers.

Full layer schematic.

More details on each of the schematics will follow after the break.

First off, let's look at the Master schematic. The master schematic features 3 distinct sections: the chipKIT, the line drivers, and all of the layers.

It was decided that each layer would require 2 serial lines for a 45% increase in speed. Other than the separate serial lines, every layer shares the same data lines. The naming conventions for each serial line follow this pattern: Panel(P)#_Serial Line(S)#. So, the first Serial In line for panel 7 would appear as P7_S1.

Also included are the other 10 signal lines in common with every layer. These lines are located on PORTE. These signals, go to line drivers. We were worried about fanout, so we put each one of these common lines to a line driver. The line drivers chosen were 74LS241. The circuit diagram is shown to the right. Each chipKIT pin drives 2 input lines on the 241's. This in turn drives 2 output pins on the line driver, which controls 12 panels of LEDs and chips.

A small example of the panels appears like the image suggests on the left. This shows the inner 2 rows of panels and the connections it makes with the above 2 images.

Finally, one also must understand the layer schematics. The following 4 photos show how this works.

This schematic reveals how power filtering for each layer will take place. Each layer has a Schottky diode. It also has filtering for high and low frequency noise.

It was decided to still have the functionality of being able to program the dot correction and other features in EEPROM while not taking up pins on the chipKIT. Therefore, jumpers are provided on each layer. This allows someone to manipulate the jumpers, write the data out to EEPROM, and then shift the jumpers back to lock it into PWM mode for normal operation.

This photo shows the ground side including the PWM chips. The only change between an early photo of the schematics and this one is the pull-up resistor on the BLANK line. This forces the PWM chips to be blanked during the 3 seconds that the bootloader takes to start up on the chipKIT.

Nothing so far has been done to the Power side of this schematic. I have this presently built on the breadboard, but have not yet gotten the chance to sit down and work on it because other commitments have gotten in the way. That is my next task in the software design is to get the demuxes working. Once I have that, I will rework the software to be the fast version, using the direct port writing as opposed to digital writes (which are extremely slow in the Arduino environment).

openFrameworks

2011-10-04T13:44:00.006-07:00

openFrameworks is an open source toolkit designed for "creative coding". Many people, especially artists, use this library to create amazing projects and presentations. A huge community of people hack, explore and share almost everything they produce and discover. Usually written in C++, openFrameworks users make innovative projects by tying other devices.

The Eyewriter from Evan Roth on Vimeo.

By using the openFrameworks library, we can use the XBOX Kinect to collect data and export them to our cube. Documents and articles for installing the oF and the Kinect can be found in openframeworks.cc

Since the Kinect can track the skeletal form of a person, why not use that data and project the user inside the cube? Aside from RGB, the Kinect device uses its 2 infrared laser cameras to tell the depth of the image in front of it. This allows us to give the projected skeleton volume and thus more character for the audience to enjoy. By simply adding a second Kinect, we should be able to map both images the Kinect records and merge them so a full 3D object can be projected inside our LED Cube. Point cloud data can be collected from the Kinect, and if we program openFrameworks correctly, we should be able to do something like the following video, but in real life...and with better music.

I already have installed and dabbled with openFrameworks a bit. I would like to begin playing around with a Kinect and my computer, but for now, until I obtain one, I'll continue researching and coding what data can be collected and exported through serial.

LEDs working together!

2011-10-04T00:09:00.001-07:00

My progress this week can be summed up in a few photos and a video.

We had gotten our parts in late in the week, so my goal was to begin down the path of software work by getting a couple of TLC's working 10 RGB LEDs. The schematic used is remarkably similar to this schematic found at theArduino Playground for TLC5940's. The only difference now that I will incorporate is that I didn't use the pull-up resistor on the BLANK signal. This now seems remarkably useful, since the chipKIT Max32 seems to write out random data on start-up, and has about a 3 second bootloader before it becomes usable.

This programming did not come along without its share of problems. First off, since I just wanted to get something going, I had to use unsigned ints, as opposed to unsigned 12 bit numbers for storing the RGB values of each pixel. It appears like I will need to overload the assignment operator, something I could not take care of in the short time span that I had. The software is fairly crude and is actually fairly slow. I was aiming for a proof of concept right now, which was exactly what I managed to achieve.

There was another head-scratcher of a problem that I was having for a while, and probably cursing TI for not more clearly stating, but I was wondering why when I would write out data, latch it in, and try to taggle the GSCLK pin for about 20,000 times for some birghtness level testing, the LEDs would flash and then shut off until the next write. I poured through the datasheet until I finally found this part of a paragraph explaining how the PWM clock actually works: " A BLANK=H signal after4096 GSCLK pulses resets the grayscale counter to zero and completes the grayscalePWM cycle. When the counter reaches a count of FFFh, the counter stops countingand all outputs turn off. Pulling BLANK high before the counter reaches FFFhimmediately resets the counter to zero." This essentially interprets down to the fact that the TLC5940 features no reset on overflow feature. Fixing the above code to toggle an entire PWM clock cycle (4096 times) and repeating that for the desired timespan fixed the problem.

Once this was fixed, I was able to then adjust values for each brightness level to show a nice progression, and hopefully I have white balanced it (according to a couple of artist friends I have at the school). My goal over the next week is shift my attention towards finishing out the schematics, getting our bending guides in so we can start assembling panels, and to create a full mockup in Autodesk Inventor for the cube itself. My biggest focus will be the PCBs and final circuit design for the cube, so that we can get these sent out to a fab house to print out for us, and get these back before the end of the term.

Below is a video explanation and demonstration of the progress made this week.

LED Cube Controller

2011-09-26T23:40:00.006-07:00

Aside from building the LED cube, another major attraction is how the cube would be controlled. There has been a few discussions on what interfaces and controls should be used. We are hoping the cube can be usable (and playable) by students and any visitor at UAT. It all came down to 3 possible options.

A Touch Interface
A 3D Joystick
XBOX Kinect Device

Touch Interface

The original plan for the project, a touch interface could be used to track fingers and map the coordinates with the cube. In order to allow full 3D tracking, the cube would require 2 touch screens. Ideally, 1 on the top face of the cube, the other on one of the side faces. The example above shows how an iPhone uses touch screen works. There are 2 conductive screens that are separated by a thin perforated non-conductive layer. When a finger presses the top of the screen, the conductors touch each other through the holes of the middle layer and map X and Y coordinates to the device. Several other touch screens use the same method.

There were some problems with this option due to some factors. Because of the side of the cube, not everyone, mainly kids, would be able to reach all corners of the touch screens. The cube should be accessible to everyone as well as keeping it ergonomic. Another draw back comes from any pending damages. If a screen were to break, it would take some time to replace the screen due to its cost. Another major flaw is the visibility of the cube with the screens attached on the sides. Although transparent touch screen would be used, it would still blur the quality of our presentation. Also, the user would have a difficult time viewing his/her interaction while controlling it.

3D Joystick

The second option for the LED Cube involved the use of a 3D joystick. Whether it be purchased or self made, a joystick provides accurate 3D tracking and control. The benefits of building a 3D joystick from scratch includes using inexpensive materials to build the device, the possibility of including accelerometers and gyro-sensors or potentiometers to the device, and avoiding the costly expense of purchasing an already built product.

It seemed to be the most plausible controller for the cube. A single dot can be moved and tracked within the cube with a 3D joystick. The problem with this controller is simply aesthetics. The project is meant to be artistic and easy to enjoy. Purchasing a joystick, like the one shown above, may be too big and bulky. Placement for the device would be crucial to the enjoyment and visibility of the LED cube. Building a joystick specifically for the cube could fit the aesthetic needs; however, the time developing a 3D joystick may push back the date for the completed finalized project. Other than that, joysticks have been overused and overdone. An awesome project should have a more interesting controller.

XBOX Kinect

In 2010, Microsoft launched the XBOX Kinect device for XBOX 360. They came up with such slogans as, "14 buttons replaced by you" and "You are the controller". The device uses 3 cameras to track movement and depth and use the data collected to allow wireless control of gamers' video games. For its release, the software development kit was released for programmers and game designers to use, prototype, and create games and applications. After the public release of device drivers for Windows, Mac, and Linux, many programmers and engineers have used the Kinect device to make several games and applications for PCs and have robots move or mirror movement.

Having such a device as a controller would be ideal for the LED project.

RGB Cube Update 1

2011-09-26T11:45:00.001-07:00

This past week offered up revisions on the schematic designafter being looked over by a manufacturing test engineer. Since he had prettymuch no part in designing the schematics, he was perfect for a review. Hecarefully poured over the datasheets, and came up with several changes thathave helped improved the schematic design.

1. Pin 3 on the CD4051B (3:8 Demux) was tied to high, sothat a pin was freed up on the microcontroller.

2. Vee and Vss were tied to ground, not 5V like I hadoriginally misunderstood.

3. The connection between XERR and gnd was broken.

4. Provided breakout jumpers so that if one still wants toprogram EEPROM, one can simply change the jumpers for a given PWM driver andprogram it.

5. Broke up the PWM drivers into 2 circuits. We kept thefirst 2 on one circuit, and put the last 2.5 on a separate circuit. This tookthe number of bits that we need to bit-bang per layer from 72 * 12 down to 40 *12, offering up about a 45% improvement in speed. So now every layer has 2serial input lines.

One concern we realized is that there is a great risk forfan-out. One microcontroller was going to be trying to drive upwards of 120chips, while only being able to output 18mA at max. This was going to be amassive problem, one that was solved by providing the 74LS240’s or 241’s oneach panel, offering up a buffer to help push that signal to all the panels. Iam unsure, as of right now, exactly how to set up the devices between thechipKIT and the layer, but I should have that next week.

We are also looking at providing 2 power supplies. One powersupply will be used for just driving the transistors. The other one will beused for all of the logic. We are hoping that providing a high and low passfilter can mean that this cube only needs 1 power supply, and can handle bothsignals, but the resulting noise may still be too much for the logic chips tohandle. Further testing will be required.

I also have some more details about the software. As Imentioned last post, I was going to be using a 3D array of a struct calledPixel. Each Pixel will hold a 12 bit value representing the PWM clock value.Also in the software I will be providing arrays for color balancing. If someonewants to update a color to a certain level, they would set it by sayingsomething like RedBrightnessLevel[12], and now that value at index 12 will bethe value stored in the red value at a given pixel. The highest brightnesslevel that we will be providing (with the exception of a possible strobeeffect) will be about 70% of the original brightness level, so that it iseasier to bear staring at the cube for long periods of time.

After talking with Microchip, their MPLAB X IDE does not yetsupport the chipKIT, our microprocessor of choice. We will be using the MPIDE,the Arduino and chipKIT compatible IDE modified by Microchip. We will beneeding to use direct port writing. Some tests have revealed that MPIDE cantoggle a pin at a max of 2.5MHz, which we need significantly faster than thatif we are to have any progress made on this. Aside from other requirements, thePWM driver datasheet provided a couple of formulas to calculate minimum frequenciesfor the PWM clock and the Serial Clock. These formulas have revealed that thePWM clock needs to oscillate at a minimum of 245.76kHz, and that the SerialClock needs to oscillate at a minimum of 28.95kHz. The PWM clock will be set tooscillate at 500kHz, and the goal for the Serial Clock will be 30kHz.

We are planning on using interrupts and timers to helpregulate these speeds, while still being able to do other functionality, likeserial communications. The highest priority interrupt will be the PWM timer,which will toggle a pin on timer overflow. I have not yet determined whether Iwant to directly control this, or use an output compare module to toggle a pin.The next highest priority interrupt will be updating the serial clock. Thisinterrupt service routine will calculate the next set of values to clock out tothe PWM driver if it hasn’t already, output these results, and clock the SCLKline. It will also be used to handle a case when everything has been updated,and it is time to shift to a new row. My goal is to be able to precalculate thenext set of values, and then just have the ISR output this. However, the seriallines coming in will take priority over this calculation inside of the mainfunction.

Finally, this week has also produced a bending guide, whichwill be used to ensure that the LEDs are all bent the same way. When assemblingthis cube, it will be nice to have consistent LEDs that we can just soldertogether. See the bottom of this post for some photos of the bending guide. The bending guide offers a tight fit to the LEDs, and ensures that these can only go in one direction. The legs are then bent appropriately. The one lead that goes away from the other leads is the power lead, which gets it above the other leads.

Other than that, no new news has come out of the past week.More updates to come!

24 X 24 X 24 RGB LED Cube

2011-09-19T21:54:00.008-07:00

The project to be accomplished this term in Robotics Project is the first layer of a 24 X 24 X 24 RGB LED cube. The design of the cube will use panels of 24 X 24 LEDs, and feature a PCB in the corner. The cube itself will feature a door that will provide access to each of the panels. Each row provides power for the LEDs, while we are going to use PWM chips to provide ground and PWM capabilities. The plan is to use 16 brightness levels, which translates into 4096 different colors per LED.

Each panel will be connected between the layers by 11 data wires, power, and ground. This connection is shown below, in Figure 1.

Figure 1. Layers and connections.

Let’s look into a single layer. One layer is located on one panel from above. Each layer features 3 major parts, the LEDs, the power circuit, and the ground circuit. We plan on using a row/column select format by putting the LEDs in a grid. The LEDs will appear in the small grid pattern shown in Figure 2, except it will be extended 8 times in each direction.

Figure 2. 3 X 3 grid of LEDs.

This grid pattern covers the LEDs, which are common anode in the current situation. Each row of LEDs requires about 1.4 A of power. This will be taken care of on the power side, which will use demuxes to drive a given transistor. This transistor is hooked up to a 5V, 30A line to drive every layer. This schematic is show in Figure 3 below.

Figure 3. Power side schematic.

On the ground side of the panel, each TLC5940 (PWM driver) is a current sink driver. The TLC chip offers resistance on each output channel, set by a resistor on the IREF pin. The ground circuit is laid out in Figure 4.

Figure 4. Ground side schematic.

Software has not yet been worked out. The idea is to use a 3D array of Pixels. Each Pixel holds a 4 bit number for red, green, and blue values representing the brightness levels. These brightness levels will then be translated into a 12 bit value, which will then be bit banged out of the microprocessor into the TLCs.

More details to come!

LEDs

2011-09-12T19:32:00.003-07:00

Ryan Carmain and Raul Garcia were discussing on on what levels of brightness they should use for their LED Cube project. Garcia asked several professors from the UAT campus including Professor Vesna Dragojlov and Professor Roy Trouerbach. Professor Trouerbach forwarded an email providing further information on how the combination of lights may affect the audience's perception of color.

"There really are no recommended brightness levels as far as I know

It all depends on how a mix of colors will create certain hues and what our preferences are for the various applications.

Color perception will change, depending on which color will have the highest brightness level.

And with LED lights the situation gets a little more complicated as there are varying LED lights that will have different
effects on how we perceive colors.

See http://donklipstein.com/ledc.html. The article is I believe from 2006."

A Maker Wedding

2011-09-02T11:53:00.001-07:00

This post is a little late in coming, but this past March I married a wonderful and patient woman, Beth. For our wedding we wanted to keep costs low and still make it very personalized, so we did all of the planning and made several custom pieces for our special day. We planned color schemes, table settings, and the hall layout using InkScape - an open source SVG editor, and Beth made beautiful blue and black ribbon table squares for the centerpieces. I designed 3D printed candle holders, and custom ties for my groomsmen presents.

More details and fancy bits after the break.

The candle holders were probably the most complicated. I wanted something that would glow nicely and display a little image and our names, and would be easy to produce. I went through a few prototypes and my school generously donated many hours of 3D printing time to make it happen.

I designed the candle holders using Autodesk Inventor, and Inkscape to construct the Orchid drawing that could be embossed on the cylinder. The material is an ABS thermoplastic, so we used cheap LED tea lights purchased from Amazon.

The candle holders turned out really well. Many people took them home as souvenirs.

Here is the Inventor Part and the STL File for the candle holder.

For the Groomsmen's gifts I designed a little robot pattern:

And used a service called ArtsCow to get it printed on ties:

Which also turned out very well, and my groomsmen really liked them (they're as nerdy as I am).

Automatic Cat Feeder

2011-09-02T11:18:00.000-07:00

It's 4am, and I'm sound asleep dreaming of robots when I'm startled awake by 10 lbs of hungry cat jumping on my face with a pleading "mew". I get up, feed the cats, and unsuccessfully attempt to resume my slumber. This scene repeated itself every day for only a couple weeks before I decided I needed an automatic cat feeder to maintain my sanity.

The feeder needed to only handle dry food, be able to ration food quantity so that the cats wouldn't get fat, and it needed to have a lot of storage so that the cats wouldn't starve while my wife and I were traveling. Similar off-the-shelf feeders cost upwards of $50, and I like a challenge, so I set out to build one myself.

Build details and more pictures after the break.

After some research, I decided on an auger-style mechanical design - the food would be held in a hopper, with a hole at the bottom that opens to the top-back of the auger chamber.

As the auger rotates, it pushes food forward to an opening at the front-bottom of the chamber, falling out into the cat food bowl.

Pretty simple, right? Not so much. My initial design didn't have a large enough output opening, so cat food would jam at the front of the opening. Once that was fixed with a little dremel magic, the problem became that cat food is a lot stickier than I expected. The feeder would meter out a few ounces of food just fine, but then would stop - the auger still rotating, but no food in the auger chamber.

Food would fall until kibble-to-kibble sticktion overcame the force due to gravity. The food in the hopper wouldn't fall - there was a little cave directly over the hopper input.

I tried a couple of solutions - one being a piece of wire that hangs down into the auger chamber, disturbing the kibble cave as the auger moves. This worked a little, but ultimately only made the kibble cave larger. I ended up re-designing the whole assembly so that the auger and auger chamber are much larger, so that kibble sticktion isn't strong enough to allow a kibble cave of that size to form.

Once the mechanicals were done, the electronics were built using a hand-built Arduino compatible circuit, a DS1302 RTC, and a serial LCD with a few buttons for menu and settings.

The whole thing runs off of a wall-wart. The software is pretty simple, incorporating a menu system to set system time, and setup feedings. The system stores feeding times and quantities in EEPROM, and there is a battery backup for the RTC so that even if there is a power outage, nobody is going hungry.

All design files are listed below:

Cat Feeder Schematic (Eagle)
Cat Feeder STL Files
Cat Feeder Parts Designs (Inventor)
Cat Feeder Firmware (Arduino)
Cat Feeder BOM (Excel)

Hash Murder: Statistical Password Breaking

2011-09-02T09:45:00.002-07:00

Joe DeMesy implemented an MPI-based parallel password hashing program as the semester project for my Parallel Programming class this semester. There have been many parallel password breaking programs implemented before, but what makes Joe's implementation unique is how trial passwords are generated. In his report, he details how he used statistical analysis of known human passwords (from Sony and Grokker leaks) to prioritize what passwords are attempted. Using this prioritization, he is able to crack a password much faster than the standard random implementation.

You can find Joe's code here.

GO GOL: Game of Life using Go Lang

2011-08-24T13:22:00.001-07:00

Iggy Kracji's semester project for my Parallel Programming class (CSC471) was to implement Conway's Game of Life using the Go programming language and the Google App Engine.
The purpose of the class was to design, implement and analyze programs that run on parallel architectures, so his output is not pretty, but functional.

You can check out Iggy's code and analysis, and test it yourself at the App Site.

JunkPOV

2011-08-24T10:32:00.000-07:00

For his Embedded Programming (RBT211) project this semester Ryan Carmain built a POV display using junk from around our hardware lab - principally the motor assembly of a Draganflyer (yes, those are propellers):

Video and source code after the break.

The POV runs on a PIC18F4550. Here is Ryan's JunkPOV code.

And video:

Engineering Challenge - Integrate Functionality & Livability

2011-04-22T12:15:00.003-07:00

Okay so maybe a few of my posts are going to be influenced by the TEDx talk I went to last night, mostly because my head started exploding with all these ideas because of the talks. So I issue a challenge to all my smarty fellow Robotics students [you can do this too Mueth], and any blog readers out there are more then welcome to join in as well. I want you to take 2 or more things and merge them in such a way to improve both their designs and functionality. To increase there aesthetic pleasure as well massively improve there use. Now at this point you're like WTF Kayla really? Yes, really. Its not hard I promise, I came up with like 3 really awesome ideas while just waiting for my ride to pick me up after the TEDx event. ^^ It was kind of funny seeing me trying to write down and draw them out as quickly as possible before I forgot them. And by the way this challenge is inspired by a Mr. Derren Petrucci who gave an amazing talk and who I think would be a good person for UAT's crazy Robotics division to work with~ *hinthintMuethhinthint*

Growing Plants Everywhere - VermiSoks

2011-04-22T11:53:00.004-07:00

Okay so I met the guy who came up with this idea, Miguel Jardine, at a TEDx Scottsdale talk last night. It really is an amazingly out there idea with a lot of potential. Pretty much you can have a self-sustained gardening system and you don't even need water. Hm.... no water, we're in a desert with little to no water... I say UAT should look into using this to take over a small part of that empty lot we own to experiment! No breaking ground or construction needed so it doesn't step on anyone's toes. So you should check it out here.

I mean seriously check out some of the pictures from the stuff Miguel grew during the middle of a summer here. The look so yummy and fresh!

Not only that but the system is simple enough where anyone can be taught how to maintain and set up this system. Pretty much what you see in the picture about is a long tube of Earthworms and coconut husks, the base of the VermiSoks system. You then take the waste produced by restaurants or CAFES [I'm looking at you Cuban Pete's] and the biodegradable stuff gets liquefied and feed into these tubes where they feed the Earthworms and then the Earthworms create this super nutrient rich environment for you to grow on. Kind of awesome huh?

Alice: A New Approach to Teaching Programming

2010-12-18T07:22:00.007-07:00

This article covers a educational videogame (if the game is programming) called "Alice" from carnegie mellon that can teach the introductory concepts behind programming.

I think its very cool that it's available online for free, and whats more I can recommend it to kids and adults alike to help them learn programming! I installed the latest "Alice 3" and while I haven't had much chance to play with it in depth, I can see some kids liking this a lot.

About 10 percent of the nation’s colleges now use Alice, an open-source, graphical software program available free online that allows users to learn the very basics of programming -- concepts like iteration, if statements and methods -- while making 3-D animations. It also has a textbook to accompany it if needed.

'Logic Gates' Made to Program Bacteria as Computers

2010-12-18T06:44:00.003-07:00

Can you say biocomputer? It's very cool in a geeky programmer/mad scientist kind of way to hear about being able to program living cells to become very tiny computers! Check out the article here!

This is slightly old new

"The purpose of programming cells is not to have them overtake electronic computers, rather, it is to be able to access all of the things that biology can do in a reliable, programmable way."

This is slightly old news though, as you can see here. Last year another group created bacterial computers capable of solving a classic mathematical problem known as the Hamiltonian Path Problem. An extention on previous work last year to produce bacterial computers that could solve the Burnt Pancake Problem.

Image-Translating iPhone App

2010-12-18T05:56:00.004-07:00

Phone apps dont get much cooler than this! The application looks for characters within an image, assembles the characters into words then looks up the word litterally in the dictionary, and then (the coolest part) not only draws the translated words over the original, but replaces them entirely! surely with the characters recognized it was simple enough to take out that color information and fill it in with the surrounding information, but wow, they did a good job I cant wait to have someone with an iPhone try this out for me in person!

How to achieve ‘biological immortality’ naturally

2010-12-18T01:58:00.003-07:00

Learn How to Stop Aging Now!

OK OK OK... So I read the paper, and as expected at the end there was a whole ton of "This is what I think people should do" from the author. but nestled in there was a interesting factor of evolutionary changes at work. While the paper is slightly laughable, nobody can take away the fact that the author bred flies that lived several times longer than average. Below was the only comment of note on the subject, but after a little more research I found this link which gives a far more detailed view of how it all came about.

He began his work on fruit flies by tricking natural selection to produce what eventually became “Methuselah flies,” for which he is well known. The trick? Take the eggs from fruit flies that have maintained enough of their physiological function to reproduce in old age, and repeat.

Selection for late-life reproduction eventually made longer-lived fruit flies. This delayed-reproduction lineage, Rose showed, lives up to five times longer than average.

Genetic Algorithm: Sudoku Solver

2010-12-18T01:22:00.004-07:00

This page features an in depth explanation with code included on how the person went about creating a GA Sudoku solver! Its also a fun read as the writer has an entertaining personality.

"I remember that I once read something from someone who tried a GA C-library on Sudoku and concluded that it was not a suitable problem. If I could solve it with my slick library, that random person on the internet, whose web page I might never find again but who may exist as far as you know, would certainly be proven wrong. A worthy cause."

Machine Learning

2010-12-17T23:52:00.007-07:00

Machine Learning

For anyone who Enjoys the topic, or just needs a good place for doing Research on machine learning, this is a great resource I've found that is extremely well referenced and full of content.
"Find a bug in a program, and fix it, and the program will work today. Show the program how to find and fix a bug, and the program will work forever."
- Oliver G. Selfridge,

Tinkercell: CAD for designing artificial life

2010-12-17T02:51:00.003-07:00

Tinkercell. This cool program is intended to make it much easier to create and simulate life on a genetic level! More Detail.

"The package has a library of the components of life, from which users can pick different cells, membrane proteins, fluorescent proteins, enzymes and genes to create their organism. Tinkercell can then simulate the life form to see if it functions as expected."

Craig Venter creates synthetic life form

2010-12-17T02:31:00.003-07:00

Artificial life is here!

Watch Craig Venter explain how his team of researchers created a new life form – and what happens next

When asked whether this latest venture wasn't, at least a bit, like "playing God?" His answer was swift and to the point. "No, we're not playing anything. We're learning the rules of life."

Google AI Challenge

2010-12-15T01:29:00.004-07:00

The online submission date is past due and after the submitted AI's duked it out and a winner has been declared, but the fun isnt over for those of you that missed the chance! Here is the page with all the starter kits in many various languages that will allow you to program an AI to play this game!

Alife Game: bSerene

2010-12-14T00:00:00.007-07:00

bSerene

While you may need an old operating system to play it,its still cool to see an evolutionary algorithm put into game AI. This site hosts download for an Alife game that offers its source code called bSerene is a game where monsters learn to play against the player via Artificial Life. The behavior of the monsters is governed by about 50 parameters, which are used as genes in a genetic algorithm. At the end of every arena the monsters that have inflicted the most damage on the players are saved to file and used as the parents of monsters in subsequent games. Monsters who are close to another monster that manages to hit you get a percentage of the credit.

Without having to look at the source code: You can change the appearance of the program by putting in your own pictures for the explosions power-ups and projectiles, or you can design your own arenas by simply modifying some txt-files in the game folder. The source code and executable game is provided for download here.

LED Text Scroller using an Arduino Mega

2010-11-02T00:46:00.007-07:00

The following project description is an entry in the Visual Representation of Learn Experience Innovate of the Academic Palloza, Fall 2010 competition held at the University of Advancing Technology.

The overall process in design is actually fairly simple. The circuit design shown in Figure 1 below shows the simple circuit used for each LED to be lit.

Figure 1. Schematic.

Figure 1 is easy to understand. Signal goes from a Digital I/O pin, through an LED, a 150 ohm resistor, and to ground. It can be repeated for as many pins as the user wants. The software is set up to run a 5 X 9 grid of LEDs. The software uses a 5 X 15 array that represents all of the LEDs plus the extra on the right, and the text scrolls to the left.

Below are several photos from the testing phases of the design and implementation of software. Below that is the source code, written for an Arduino Mega.

Early testing phase of the design and wiring.

Testing of everything wired.

The video above shows an early version, before the resistors were added to the LEDs (A VERY BAD CHOICE TO DO) and before the serial communication was working.

The source code can be found here.

Expect to work about 5 hours to get all of the wiring working, and the source code implemented and debugged for your setup.

Nameless Microwave gets Down N' Dirty[Video]

2010-10-22T02:08:00.006-07:00

Things are moving fast for the RoboWargames team. In and out of UAT. The team (headquarters located in the 244 hardware lab) took their stock Parallax rover out for a spin yesterday after refueling it with both hydraulic fluid and gasoline. After a short warm up and a few minor hiccups the rover was soon getting carried away with itself. Under the control of a remote ofcourse. The max speed of the rover is ~15 mph but due to the hydraulic settings it was cruising at a good ~10 mph.

The rover will eventually be pimped out with a laser range finder, onboard cameras, various sensors, a sleek casing, and autonomous programming. It will be our entry into the IGVC (Intelligent Ground Vehicle Competition) in the summer of 2011.

Visual 6502 Processor Simulation

2010-09-19T16:48:00.000-07:00

Greg James, Barry Silverman and Brian Silverman from Visual6502.org have been working for the last year on a transistor-level visual simulation of the 6502 microprocessor. Their work is incredibly detailed and very interesting. The 6502 design is a classic processor, and very important in computer history as it was used in the Apple I & II, Commodore, Atari and Nintendo computing systems.

In the summer of 2009, working from a single 6502, we exposed the silicon die, photographed its surface at high resolution and also photographed its substrate. Using these two highly detailed aligned photographs, we created vector polygon models of each of the chip's physical components - about 20,000 of them in total for the 6502. These components form circuits in a few simple ways according to how they contact each other, so by intersecting our polygons, we were able to create a complete digital model and transistor-level simulation of the chip.

Prizes for Electric Car Algorithms

2010-08-04T22:14:00.000-07:00

The CREATE Lab at Carnegie Mellon University is sponsoring a contest to develop efficient battery-management algorithms for electric vehicles. At the end of every month, high-performing entries will be awarded small prizes ($100 in Amazon gift cards), with a grand prize (possibly an actual electric vehicle) awarded at the end of the competition. At the end of each monthly judging phase, entries are open-sourced for all to see and share.

Autonomous Battery Exhange

2010-07-11T12:19:00.001-07:00

Researchers at Ecole Polytechnic in Lausanne have developed marXbot and snazzy battery exchange system. The batteries are modular and charge in a kind of ferris-wheel. When the robot runs low on juice, it docks with the station, and the dead battery is removed from the robot chassis by a manipulator. During the swap, robot power is provided by an alternate ultra-capacitor based system that can provide 15 seconds of power for the critical systems (i.e. only maintaining cpu memory state). The wheel rotates to a fresh battery, and the manipulator pushes it into the chassis, completing the hot-swap.

Graffiti Analysis Sculptures

2010-06-29T22:12:00.000-07:00

Graffiti Analysis: 3D from Evan Roth on Vimeo.

Graffiti Analysis: Sculptures is a series of new physical sculptures that I am making from motion tracked graffiti data. New software (GA 3D) imports .gml files (Graffiti Markup Language) captured using Graffiti Analysis, creates 3D geometry based on the data and then exports a 3D representation of the tag as a .stl file (a common file format compatible with most 3D software packages including Blender, Maya and 3DS Max). Time is extruded in the Z dimension and pen speed is represented by the thickness of the model at any given point. I then have this data 3D printed to create a physical sculpture that serves as a data visualization of the tag. For the Street and Studio exhibition at the Kunsthalle Wein, I collaborated with an anonymous local Viennese graffiti writer and had the GA sculpture printed in ABS plastic. Graffiti motion data of his tag was captured in the streets (for the first time) at various points around Vienna.

More information (including software, source code, and many more pictures) can be found at Evan's website.

Self-Folding Origami

2010-06-29T22:01:00.000-07:00

Robert Wood of Harvard University, Daniela Rus and Erik Demaine at the Massachusetts Institute of Technology take us to a new level of robotic creepiness with self-folding origami. The device is able to morph itself into new shapes using shape-memory alloys that line the edges of triangular modules. Each module also sports a strong magnet that holds the final form after a module has executed a desired fold.

3D Printed UAT Shadow Sculpture

2010-06-09T21:54:00.001-07:00

Last week I built this shadow sculpture inspired by the cover of the Pulitzer-prize winning book "Gödel, Escher, Bach: An Eternal Golden Braid" this is a 3D-printed form that casts three orthogonal shadows in the shapes of the letters UAT. After I printed it, I used some blue LEDs and foam-core to build a little display platform for it.

Here is the Inventor part file: UATCube.ipt

The Guardian: Inexpensive AVR-based Cat Food Protection

2010-05-31T12:04:00.001-07:00

Over 6 months ago we added two kittens (Duke and Ella) to our household, and we found out that our dog, Riley was eating their food. To prevent this, I built the Guardian, an AVR-based protection system that humanely keeps Riley away from the cat food, but is not triggered by the cats themselves.

I wanted this setup to be cheap, so I decided to use an infrared "trip-wire" system. On one side of the hallway is an always-on infrared emitter, and on the other side is an infrared receiver, an AVR ATmega8 microcontroller, and a buzzer. The micocontroller continuously checks to see if the beam between the emitter and receiver has been broken - if it has, it sounds the alarm, which Riley hates, driving him away. The microcontroller is programmed so that small, fast things (such as cat tails) do not trigger the alarm. Also, the whole rig is place at Rileys shoulder height, which is much taller than the cats bodies.

This may not work for most dogs, as Riley is a pansy and afraid of loud noises, but here are the schematics, source code, and a rough bill of materials:

Schematics (Eagle, PNG)
Source Code
Bill of Materials

3D Printed Tensegrity Structure

2010-05-29T23:21:00.002-07:00

This weekend I built a Tensegrity structure as a demonstration of principles of balancing tension and compression in structures for my course RBT379 - Mechatronics. I've been fascinated by the aesthetic of these structures - all triangles and edges, but somehow magical as your brain tries to wrap itself around the reasons why the solid supports seem to be floating in air, and the structure is still standing.

I found a couple of excellent pages documenting how the structures work and are assembled - one from the artist Kenneth Snelson explaining the aesthetic inspiration for Tensegrity structures as a kind of 3-dimensional weaving, and another more practical site detailing the construction of a Tensegrity coffee table.

I used the UAT 3D printer to make 12 struts. You can make these out of much simpler materials (wood, copper, chopsticks, etc), but the Inventor Part design for the struts are provided here. A gallery of the build process and completed 3-level structure (and one rubber-band version) are below.

I used 20lb test mono-filament fishing line and 2 sets of good smooth-jaw pliers to tie the knots (grip-jaw pliers scar the fishing line, causing breaks after you've carefully tied many little knots), following the guidelines at the Tensegrity coffee table website. If you do this yourself, construct a jig that will allow you to accurately create the tension links at a certain distance (the length of your struts divided by 1.4).

I built 3 modules, 2 "left-handed" and 1 "right-handed." To assemble them into the tower, I hooked the struts of one module into the base triangle of tension elements of another, forcing the base triangle into a hexagon.

The resulting structure is surprisingly sturdy, and the fishing line is somewhat transparent, adding to the mystical effect I was trying to emphasize.

ArcAttack: Ride the Lightning

2010-05-26T20:18:00.001-07:00

I've always been fascinated by Tesla Coils. The operating principle is so elegant - you set up one circuit (your power supply) that oscillates at some high frequency, and you set up another circuit that uses the earth to resonate with your power circuit. Energy is transferred and converted from current to voltage, and the end result is man-made lightning - an incredible display of light and sound.

Newer versions of the Tesla coil allow the control of the resonant frequency. Have you ever noticed the sound that a flourescent light makes? That kind of "buzz" ? You're hearing the frequency of the power that is coming into your house (around 60Hz). When you control the resonant frequency of the Tesla, you control the tone that it generates, and thus the Singing Tesla Coil is born. This is not lightning set to music - the sound is generated by the spark itself.

The band ArcAttack has integrated a pair of singing Tesla coils into their repertoire, with epic results:

Inventor Models

2010-05-23T23:59:00.000-07:00

For this semester's Mechatronics course (RBT379) the semester project is to build a self-balancing two-wheeled robot from scratch. Over the course of the semester we will be designing the frame of the robot, constructing the control schematic, laying out a PCB, and finally programming the micro-controller to self-balance using a PID loop.

The first part of the semester we're using Autodesk Inventor to design and layout the frame of the robot. To help with this process I've modeled the major components. I had a really difficult time finding models of these online, so I'm sharing them with the world:

Standard Servo: Modeled after the Parallax Continuous Rotation Servo
Inventor Part (*.ipt), Drawing (*.pdf)

Parallax Boe Bot Wheel - Inventor Part (*.ipt), Drawing (*.pdf)

Sharp GP2D12 - Inventor Part (*.ipt), Drawing (*.pdf)

Switched AAx4 Battery Box - Modeled after Jameco PN#216187
Inventor Part (*.ipt), Drawing (*.pdf)

Circuit Board, 80mm x 100mm (Maximum Eagle Free dimension), 4mm holes.
Inventor Part (*.ipt), Drawing (*.pdf)

SparkFun SEN-09652 Triple Axis Accelerometer Breakout Board
Inventor Part (*.ipt), Drawing (*.pdf)

Most of these I measured by hand, so take the dimensions with a grain of salt, but they should be accurate within a millimeter or so.

Human Tetris

2010-05-16T18:28:00.000-07:00

Cornell Students Adam Papamarcos and Kerran Flanagan have built an awesome set of small games using micro-controller based video processing. The details of the build (excellently documented - my students should take note) are provided at the Cornell Project Website, and more videos detailing how the system works are available at Engadget.

RBT337 Final Project: Augmented Reality Pong

2010-05-13T08:48:00.000-07:00

Dan Willinger is back with his final project for RBT337 - Digital Vision and Sensor Processing. Using OpenCV, Dan implemented an augmented reality Pong clone that tracks the size and location of two white objects (pens in the demo video) that act as the paddles in the game. Also, the length of the white object can change the size of the paddle.

The Facade Printer

2010-05-11T21:18:00.000-07:00

Automated Paintball Turret = Large Scale Printer.

This is a project I've wanted to build for years - my own concept was to construct a system powerful enough to paint a graphic on the side of a dorm at my Alma Mater from across campus.

Laser Command

2010-05-10T21:52:00.000-07:00

Laser Command from Eiji Hayashi on Vimeo.

This awesome project was built by Eiji Hayashi at Carnegie Mellon University. What stands out is the use of LED's as both display and input. The full design is available here.

UAT Educational Robot Platform

2010-05-05T14:52:00.001-07:00

This is a motor test of the UAT Educational Robot Platform, developed as a class project by Dan Willinger and Stephen Harper. The robot will be used as a learning platform for advanced sensor interfacing and mobile autonomous system development at the University of Advancing Technology. This is one of the two robots that Dan and Stephen built, each costing about $1200.

Here are specs for the robot:

Mini-ITX Motherboard with Atom 230 CPU (1.6Ghz)
2GB RAM
8GB Solid-State Storage (Compact Flash)
Firewire
WiFi
PicoPSU DC-DC 150W Power Converter
Track Chassis Kit
Lithium-Ion Battery (25.9v, 6.4Ah)
Phidget Motor Control Board
Phidget USB Interface Board
Running Ubuntu Server Edition (9.10)
Custom Clear Lexan Chassis

RBT337 Final Project: Face Recognition

2010-05-05T14:34:00.000-07:00

A demonstration of the final project for my course RBT337 - Digital Vision and Sensor Processing by Brittany Wilkerson and Casey Johnson. Their final project used OpenCV's face detection and SURF algorithm to identify faces in a live video feed.

RBT173 Final Project: Accelerometer Controlled Robot

2010-05-05T14:23:00.000-07:00

A final project demonstration by Ryan Carmain, Kayla Bayens, and Leonard Hockett of their Accelerometer controlled robot. This project was for my course RBT173 - Introduction to Microcontrollers. The controller uses an accelerometer to sense the direction of gravity, which is sent over a serial connection to the robot, and translated into motor commands.

RBT173 Final Project: Text-to-Speech Twitter Robot

2010-05-05T14:01:00.000-07:00

This is Andre Walker's final project for my course RBT173 - Introduction to Microcontrollers. The project is a text-to-speech robot that mimics emotions and reads specially tagged twitter messages out loud. It is a modified version of the GanzBot project.

RBT337 Final Project: Glyph Tracking

2010-05-04T17:58:00.000-07:00

Mike's back, demonstrating his final project for UAT's Digital Vision and Sensor Processing course. In this video, Mike is demonstrating his SURF-based Glyph tracking system. Take it away Mike!

RBT337 Final Project: Connect 4

2010-05-04T17:50:00.002-07:00

For their semester project in UAT's Digital Vision and Sensor Processing course, Josh Butler and Mark Stoddard implemented an excellent Connect 4 augmented reality program that warns a user if 3 pieces of the same color are placed in a row by highlighting the warning area in green. If a set of 3 is blocked, it is eliminated as a possible "win."

This first video shows the program in operation, live, raw video in the top left, augmented video in the bottom left, and color filters on the right for red and black pieces.

This second video demonstrates some of the inner workings of the program.

The bottom left pane now shows how the program scans over the all of the possible positions in the live feed, determining if the location contains a red or black piece, or is empty. This information is used to populate an array internally, which is then checked for "3 in a row."

RBT337 - Optical Flow

2010-05-04T17:30:00.000-07:00

This is another assignment in UAT's Digital Vision and Sensor Processing course. In this laboratory, students are tasked with implementing and comparing optical flow algorithms, one using Lucas Kanade, and another using SURF.

Here is Mike Peters demonstrating optical flow using the Lucas Kanade algorithm:

And the SURF Algorithm:

RBT337 - Object Tracking

2010-05-04T17:05:00.000-07:00

As one of the laboratory assignments in the UAT Digital Vision and Sensor Processing course, students implement the OpenCV SURF algorithm on a live video feed. Here are some example videos of what my students produced. In the videos, the white lines indicate the tracking of matched features in one image (usually a target) to another (the live video).

(By Josh Butler)

(By Leonard Hockett)

(By Ryan Carmain)

(By Mike Peters)

Giant, Post-Apocalyptic "Rescue" Robot

2010-04-27T19:47:00.001-07:00

I found this gem in a gallery of vintage robots featured in Popular Science.
This robot, called "The Beetle" weighed 170,000 pounds and cost $1.5 Million in 1962. It was originally designed as a "mechanic's suit" for some kind of half-baked nuclear-powered airplane. There are more awesome pictures in the original article, particularly of the "pilot" sitting behind 2 feet of leaded glass.

The whole thing looks like something out of the movie Aliens.

Virginia Tech's new CHARLI-L robot

2010-04-27T13:21:00.001-07:00

CHARLI is actually a series of robots that initially consists of the 5-foot tall CHARLI-L (or lightweight, pictured above), and the forthcoming CHARLI-H (or heavy), both of which are completely autonomous, with a full range of movements and gestures thanks to a series of pulleys, springs, carbon fiber rods, and actuators (not to mention some slightly more mysterious AI). What's more, while CHARLI-L is currently restricted to walking on flat surfaces, CHARLI-H promises to be able to walk on the uneven ground around the Virginia Tech campus, and eventually even be able to "run, jump, kick, open doors, pick up objects, and do just about anything a real person can do."

This robot reminds me a lot of the machines from I, Robot. I can't wait until machines like these are ninja-ing around the world.

AI-Controlled Mario and Level Generation

2010-04-27T13:11:00.001-07:00

Last year, the IEEE Symposium on Computational Intelligence And Games hosted a competition where participants were asked to develop an AI that can play mario. Here's an example of a winning AI player:

This year they've added a level-generation aspect to the competition.

The level generation track of the competition is about creating procedural level generators for Infinite Mario Bros. Competitors will submit Java code that takes as input desired level characteristics, and output a fun level implementing these particular characteristics. The winner will be decided through live play tests.

For more information, visit the 2010 Mario AI Championship page.
They also have competitions based on Ms. PacMan, StarCraft, and others.

Spinning RGB LED Ball

2010-04-27T12:55:00.000-07:00

Unlike it’s predecessor this one has three axes. It was very challenging to build, with a total of 9 slip-contacts, not including the motors. I made it from scrap I had laying around and it took about a week to build. I use standard DC-motors controlled with pulse width modulation, the LEDs are controlled with a modified bike light with adjustable frequency.

More pictures via HackedGadgets

Natural Motion for CG Characters

2010-04-23T09:23:00.001-07:00

New algorithms from NaturalMotion allow digital characters to dynamically and realistically respond to changes in their environment. What is most interesting about this work is that the methods that they use are not hard-coded - rather than completely and painstakingly modeling the motion of walking characters by hand, they use a mixture of physics modeling and evolutionary algorithms to allow the system to 'learn' how to react to the environment. This enables the characters first to learn about walking, then dynamically adapt to perturbations like pushes and hits from objects and other characters. This results in very robust and realistic motion.

Man's Best Mechanical Friends

2010-04-22T10:26:00.000-07:00

A gallery of robo-pooches via BoingBoing

A new look for the UAT Robotics Blog!

2010-04-22T09:53:00.000-07:00

A New banner, thanks to the excellent graphic design skills of Phillip Taylor.

Your daily dose of creepiness

2010-04-20T15:29:00.003-07:00

Time for another trip into the Uncanny Valley:

Delta Robots

2010-04-20T15:24:00.000-07:00

Adept's new Quattro arms are hard to beat:

So you might want to build your own:

Bots Behaving Badly

2010-04-12T22:24:00.000-07:00

Have you ever wanted to meet a Mythbuster in real life? Have you ever wanted to see behind the scenes of a ComBots event, and see how some of the world’s most badass robots are built? Now’s your chance to do both of those things at once! Enter the RoboGames 2010 Bots Behaving Badly Contest! Take a video, take a picture, or make a photoshop of a robot behaving badly, and submit it to YouTube, or Flickr. Get everyone you can to check it out, because the submission with the most views wins!!

How To Enter:

- Take a video or a picture, or make a photoshop of a robot behaving badly
- Upload it to YouTube or Flickr, with the tag “BadBots2010″ (IF YOU DON’T, YOU WONT BE ENTERED)
- Every submission MUST link prominently to RoboGames.net, and somehow be related to Bots Behaving Badly (this is at the judges’ discretion)
- Share your entry- send it to friends, post it on digg etc etc etc
- The entry with the most views wins!

Prizes:
1st Place: 2 tickets to RoboGames 2010, 2 passes to the RoboGames Builder’s Party on Friday, April 23, a RoboGames Goodie Bag, and access to the pit at RoboGames (where contestants build their robots) with a meet-and-greet with Mythbusters’ Grant Imahara

2nd Place: 2 tickets to RoboGames 2010, 2 passes to the RoboGames Builder’s Party on Friday, April 23, 2 RoboGames T-Shirts, and 2 packs of RoboGames Trading Cards

3rd Place: 2 tickets to RoboGames 2010, a RoboGames T-Shirt and a pack of RoboGames Trading Cards

Judges Award: 1 ticket to RoboGames and a RoboGames T-Shirt

Deadline: 4/22/2010 at 11:59pm

Can’t make it to RoboGames? No problem! Alternatives to tickets will be also available to winners!

All rules subject to change without notice

The Fine Print:
· Participants agree to abide by all rules and decisions set by RoboGames.
· RoboGames reserves the right to reject an entry for any reason.
· Should a winner be unable to attend RoboGames 2010, RoboGames will determine an appropriate substitute of approximately equal value.
· RoboGames reserves the right to modify or cancel the contest at any time, at its sole discretion.
· By submitting your entry and entering this contest, you grant RoboGames royalty-free rights to publish, reproduce, or otherwise distribute your work commercially or by any other means.
· Governing Law: All issues and questions concerning the construction, validity, interpretation and enforceability of the official rules, or the rights of entrants, shall be governed by and construed in accordance with, the substance laws of the State of California and any applicable laws and regulations of the United States.
· You must be over the age of 18.

Massive Music Machine

2010-04-12T22:13:00.003-07:00

Pat Metheny's Orchestrion.

If you've got $33, he's playing with the Orchestrion this Friday at the Mesa Arts Center. See Tour Dates for details.

Spider Robots in Pictures

2010-04-12T22:05:00.000-07:00

Wired has a great/creepy archive of arachnid automatons.

Court rules against Net Neutrality

2010-04-08T18:13:00.000-07:00

Recently a federal appeals court ruled against the Federal Communications Commission on net neutrality. In the case, Comcast was challenging the power of the FCC to tell Comcast how to manage its network, specifically pertaining to Comcasts ability to throttle bit-torrent network traffic.

If you support Net Neutrality and want to see it enforced by law, contact your congresscritter and tell them how you feel!

Spare Bots!

2010-04-08T18:05:00.000-07:00

Flickr user Lenny&Meriel makes tiny robot scenes from scrap electronics components!

A Real Turing Machine

2010-04-03T10:17:00.000-07:00

Mike Davey presents his hand-built Turing Machine. The machine uses a Parallax Propeller chip for mechanical control, but actual computation is executed using the tape reel.

My goal in building this project was to create a machine that embodied the classic look and feel of the machine presented in Turing’s paper. I wanted to build a machine that would be immediately recognizable as a Turing machine to someone familiar with Turing's work.
Although this Turing machine is controlled by a Parallax Propeller microcontroller, its operation while running is based only on a set of state transformations loaded from an SD card and what is written to and read from the tape. While it may seem as if the tape is merely the input and output of the machine, it is not! Nor is the tape just the memory of the machine. In a way the tape is the computer. As the symbols on the tape are manipulated by simple rules, the computing happens. The output is really more of an artifact of the machine using the tape as the computer.

You can get more details about the construction of the machine at Mike's Site.

Robots in Pictures

2010-04-03T10:00:00.001-07:00

The Boston Globe has a great series of robot pictures. Part 1, Part 2, Part 3.

Practice Makes Perfecgt

2010-04-03T09:45:00.000-07:00

From Flickr user mrbbking:

Two copies of the same circuit. The one on the right was done first, and is a pretty good rat's nest, if I do say so myself. The one on the left was built based on the other one, but with an eye toward clarity. Much easier to see what's going on! I guess that figuring out the layout based on a schematic is a skill that needs practice.

ViBe Background Extraction

2010-03-29T21:43:00.000-07:00

Researchers at the University of Liege in Belgium have made a breakthrough in machine vision. Background extraction is the separation of a "normal" background image from more interesting "new" pixels such as moving objects.

This new algorithm is very high performance and computationally efficient. Unfortunately, it's completely patented, but a demo video and a paper describing the method are linked below.

O. Barnich and M. Van Droogenbroeck. ViBe: a powerful random technique to estimate the background in video sequences. In International Conference on Acoustics, Speech, and Signal Processing (ICASSP 2009), pages 945-948, April 2009. Available as a IEEE publication or on the University site.

Inventor and 3D Printing Demo

2010-03-25T13:14:00.000-07:00

Here's a time-lapse video I made demonstrating the Autodesk Inventor interface and 3D printing. The model I'm making is a simple robot hand finger tip. The total time, from conception to physical model, is about an hour.

RBT173 - Simple Simon Game

2010-03-24T21:40:00.000-07:00

Here is another lab demonstration from some of my students in RBT173 - "Introduction to Micro-controllers."

The goal of the laboratory was to construct and program a simple breadboard "Simon" style game. Some of the challenges of this lab were construction of input and output circuits, and generating a random sequence of light blinks. The most challenging part of this lab for most students was recognizing user input and determining whether it matched the generated quiz sequence.

A hundred tiny feet...

2010-03-24T21:12:00.000-07:00

This might be an awesome project for next semester's Mechatronics students.

The legs are based on Theo Jansen's designs. You can get a good idea of how they work through this Actionscript Physics Engine simulation. My favorite "Strandbeest" is the Animaris Rhinoceros:

64 Pixel Mario

2010-03-13T11:46:00.000-07:00

Super Mario Bros on an 8x8 LED matrix from Chloe Fan on Vimeo.

Chloe Fan has blown our minds by showing that you only need 64 pixels to have a little fun with Super Mario Bros.

Via Make.

Kiva Robotics' Nutcracker

2010-03-10T21:08:00.001-07:00

Cardboard Phone Robots

2010-03-10T20:43:00.000-07:00

It's not word soup, it's an article at Wired.

This is the kind of thing that I'd like to see students produce in the Physical Computing Studio (RBT307) course next semester. Quick, dirty robots held together by hot glue and electrical tape. The idea is that once we strip away the requirement of long-term durability, we can move quickly through design iterations, and learn a great deal about functional, physical design and manufacturing methods.

Iron Man 2

2010-03-10T20:29:00.000-07:00

I. can. not. wait.

Old School Robotics

2010-03-09T18:59:00.000-07:00

When I was growing up, I was destined to be an engineer. I would go to the library and check out every book I could on robots - big picture books of robots, children's books on robots, even some academic books that I couldn't really understand as a child, but the diagrams and illustrations captivated me. I was enchanted by the idea of building my own machine.
Make has a short article on one of my favorites, and I'm now destined to spend the rest of my evening perusing the Old Robots website.

M3: Neony & Synchy

2010-03-08T20:38:00.001-07:00

Baby Robots!

I'm 100% certain these will grow up to kill us all.

USB Oscilloscope on the cheap

2010-03-08T20:31:00.001-07:00

Build your own tools!
This ATiny45-based dual channel oscilloscope is home-made, cheap and simple. It doesn't capture at high sample rates, but it's neat nonetheless.

Design, source code and interface code available here.

Towards Smart Dust

2010-03-05T08:47:00.000-07:00

A 9-cubic millimeter solar-powered sensor system developed at the University of Michigan is the smallest that can harvest energy from its surroundings to operate nearly perpetually. The U-M system’s processor, solar cells, and battery are all contained in its tiny frame, which measures 2.5 by 3.5 by 1 millimeters. It is 1,000 times smaller than comparable commercial counterparts.

RBT173 - Larsen Scanner

2010-03-05T08:43:00.002-07:00

Here is a short video of some of my freshman students completed lab assignments.

This is an early laboratory assignment in a freshman-level course. The assignment takes the place of the typical "Hello World" blinking light program for micro-controllers. The course is RBT173: Introduction to Microcontrollers. We're using hand-built Arduino-compatible micro-controller boards and exploring all of their ins and outs with a series of weekly hardware / software labs culminating in the construction of a small mobile robot based on the board.

For more information, visit www.uat.edu/robotics .

Gaagle Bot Indexes Your Home

2010-03-05T08:36:00.000-07:00

A roomba-based manifestation of the Google search crawler.

Check it out with hardware details and source code at www.gaaglebot.com.

Kohctpyktop: A logic design challenge

2010-03-03T10:05:00.000-07:00

Feeling nostalgic for those frantic days in the digital design lab? Wish there were perhaps a game that put you in the place of an engineer, trying to design new ICs to meet the goals of some unspecified organization? Want to get your SI on? No idea what I am talking about?
Well then, let me introduce you to Kohctpyktop: engineer of the people, by Zachtronics Industries. It's the first game I've ever seen where you have to design integrated circuits as a challenge, sort of like pipe dream for electrical engineers.

Kohctpyktop via Make

OK GO - This too shall pass

2010-03-03T10:01:00.004-07:00

Rocks my socks.

Expressive Telepresence with MIT's MeBot

2010-03-01T22:51:00.000-07:00

A totally sweet little robot from Sigurdur Orn Adalgeirsson at MIT.

Sell your designs through BatchPCB!

2010-03-01T22:33:00.003-07:00

BatchPCB is starting a new service where circuit designers can sell their boards through the BatchPCB Marketplace.

NEW FEATURE FOR BATCH PCB!
Mar 1, 2010

So you made a PCB design? Think others might benefit from it? Sell it! You can sell as many (or as few) designs as you want and can receive payment via check or paypal.

Does anyone remember "Batteries Not Included" ?

2010-03-01T22:16:00.000-07:00

Built by SauliusS

Compressed Sensing - Getting something for nothing

2010-03-01T21:54:00.003-07:00

Wired has an interesting article on the data-manipulation techniques that could lead to real Blade-Runner / CSI style image enhancement.

1 Undersample
A camera or other device captures only a small, randomly chosen fraction of the pixels that normally comprise a particular image. This saves time and space.

2 Fill in the dots
An algorithm called l₁ minimization starts by arbitrarily picking one of the effectively infinite number of ways to fill in all the missing pixels.

3 Add shapes
The algorithm then begins to modify the picture in stages by laying colored shapes over the randomly selected image. The goal is to seek what’s called sparsity, a measure of image simplicity.

4 Add smaller shapes
The algorithm inserts the smallest number of shapes, of the simplest kind, that match the original pixels. If it sees four adjacent green pixels, it may add a green rectangle there.

5 Achieve clarity
Iteration after iteration, the algorithm adds smaller and smaller shapes, always seeking sparsity. Eventually it creates an image that will almost certainly be a near-perfect facsimile of a hi-res one.

I haven't seen the original paper, so I'm a little skeptical. I'd like to see what kind of error is incurred by this successive approximation. How different is the reconstructed image from the original? There are always limits to these things.

NASA's Golden Boy - Project M

2010-03-01T21:06:00.001-07:00

IO9 has a great writeup on NASA's Project M to send humanoid telerobots to the moon in lieu of human exploration.

Inside Google

2010-02-24T23:17:00.000-07:00

Wired has an excellent article on how the Google search engine works and it's continued development.

What strikes me about this article is how many times the core Google search engine has been revised - 5 major changes to the fundamental search architecture over the last 13 years. Also, the details about how Google handles "bi-gram breakage" are awesome. This kind of processing requires an very high level of 'understanding' of the human world, and Google is doing it extremely efficiently. This is the kind of system that is going to wake up one morning and take over it's own development.

Just like Mombot used to Make

2010-02-24T22:58:00.001-07:00

A New York Times article about food preparation and snack delivery robots.

BreakfastBot is ready to use his tiny, tiny hands to scramble your eggs.