Did you know there are a million little mirrors flickering back and forth, reflecting light within some modern projectors; like a flip-dot display but at the micro level? In his video, [Ben Krasnow] explains the tiny magic at work in DLP, or digital light processing technology with a scaled up model he constructed of the moving parts.
LCD projectors work much like old slide projectors. Light is shined through a transparent screen containing the image, which is then focused and enlarged through a lens. DLP projectors however achieve the moving image in a slightly different way. A beam of focused light is shined onto a chip equipped with an array of astonishingly small mirrors. When the mirror is flipped in one direction, it reflects the light out through the lens and creates a visible pixel. When the mirror is tilted the opposite direction, no light is reflected and the pixel is dark. All of these tiny moving parts are actuated by means of static electricity, and since a pixel can effectively only either be in an on or off state without any range of value in-between, the pixel must flutter at a rate fast enough to achieve the illusion of intensity, much like pulsing an LED to create a dimming effect.
In addition to slicing open the protective casing of one of these tiny micro-mirrored chips to give us a look at their physical surface under a microscope, [Ben] also built his own functioning matrix from tiles of mirrors and metal washers sandwiched around pieces of string. A wound electromagnet positioned behind each tile tilts the pixel into position when a current is run through the wire — although he didn’t sink the time needed to build out the full array in this manner (and we don’t blame him). If you do have the time and add in a high powered flash-light, this makes for an awesome way to shine messages on your roommate’s wall.
Continue reading “Digital Light Processing, So Many Tiny Mirrors”
[ElectricSlim] likes taking “Jump Shots” – photographs where the subject is captured in midair. He’s created a novel method to catch the perfect moment with OpenCV and Processing. Anyone who has tried jump shot photography can tell you how frustrating it is. Even with an experienced photographer at the shutter, shots are as likely to miss that perfect moment as they are to catch it. This is even harder when you’re trying to take jump shots solo. Wireless shutter releases can work, but unless you have a DSLR, shutter lag can cause you to miss the mark.
[ElectricSlim] decided to put his programming skills to work on the problem. He wrote a Processing sketch using the OpenCV library. The sketch has a relatively simple logic path: “IF a face is detected within a bounding box AND the face is dropping in height THEN snap a picture” The system isn’t perfect, A person must be looking directly at the camera for the photo the face to be detected. However, it’s good enough to take some great shots. The software is also repeatable enough to make animations of various jump shots, as seen in [ElectricSlim’s] video.
We think this would be a great starting point for a trigger system. Use a webcam to determine when to shoot a picture. When the conditions pass, a trigger could be sent to a DSLR, resulting in a much higher quality frame than what most webcams can produce.
Continue reading “Perfect Jump Shots with OpenCV and Processing”
The blue board seen above is the guts of a product called the eeColor Color3. It was designed to act as a pass-through between your television and HDMI source device. It boasts the ability to adjust the color saturation to suit any viewing conditions. But [Taylor Killian] could care less about what the thing was made for, he tore it open and used the FPGA inside for his own purposes.
The obvious problem with this compared to a proper dev board is that the pins are not all broken out in a user-friendly way. But he got his hands on it for free after a mail-in-rebate (you might find one online for less than $10 if you’re lucky) and it’s got an Altera Cyclone IV chip with 30k (EP4CE30F23C6N) gates in it so he’s not complaining. The first project he took on with his new toy was to load up an open source Bitcoin mining program. The image above shows it grinding away at 15 megahashes per second while consuming only 2.5 watts. Not bad. Now he just needs to make a modular rack to hold a mining farm.
It’s the end of the semester for [Bruce Land]’s microcontroller design class at Cornell, and the projects coming off the workbench this semester look as awesome as any before. For their final project, [Alexander Wang] and [Bill Jo] designed an audio frequency spectrum analyzer using two microcontrollers in a parallel setup.
This spectrum analyzer takes an audio signal from an iPod, phone, or CD player through a 3.5 mm jack and displays the level for dozens of frequency bands much like an audio visualizer in iTunes or a nice car stereo display. To display these frequency bands, the spectrum analyzer first needs to perform a Fast Fourier Transform on the incoming audio signal. While FFT is extremely fast, the calculations are rather hardware intensive; calculating the frequencies and displaying them on a TV would be a bit much even for the ATMega1284 used in the project.
To graph the audio signal on their small display, [Alexander] and [Bill] broke the build up into two parts – one to do the math on the audio, and another to generate the NTSC video signal for the display.
As seen in the video after the break, the spectrum analyzer works wonderfully, and even though it only functions up to 4kHz, it’s more than enough to see what’s going on in most music.
Continue reading “Building a spectrum analyzer with parallel processing”
To be honest, we’ve heard of dithering but that’s the extent of our knowledge on the topic. After looking through [Windell’s] post about using Dithering in Processing we can now say we’ve got a base of knowledge on the topic.
Dithering is used to produce an image out of two colors that our eyes can put together into something meaningful. The history of the algorithms goes back to monochrome displays. But now the hobby electronics we work with for fun have comparable computing power and perhaps it’s time to rediscover these techniques. [Windell’s] project implements the Atkinson dithering algorithm in real-time on your webcam. He’s doing this in Processing, which should make it pretty easy to port for your own purposes.
So why might you want to use dithering in your own projects? Because if it can be used to make very cool milled artwork there must be other undiscovered uses lurking around your workshop.
[Tomáš], a.k.a. [Frooxius] is playing around with computational theory and processor architectures – a strange hobby in itself, we know – and has created the strangest CPU we’ve ever seen described.
The Weird Processing Unit, or WPU, isn’t designed like the Intel or ARM CPU in your laptop or phone. No, the WPU is a thought experiment in computer design that’s something between being weird for the sake of being weird and throwing stuff at the wall and seeing what sticks.
The WPU only has four instructions, or attoinstructions, to change the state of one of the 64 pins on the computer – set to logical 1, set to logical 0, invert current state, and halt. These instructions are coded with two bits, and the operand (i.e. the wire connected to the computer) is encoded in another six bits.
These 64 wires are divided up into several busses – eight bit address and control busses make up the lowest 16 bits, a 32-bit data bus has a function akin to a register, and a 16-bit ‘Quick aJump bus’ provides the program counter and attocode memory. The highest bit on the WPU is a ‘jump bit’, implemented for unconditional jumps in code.
We’re not even sure the WPU can even be considered a computer. We realize, though, that’s probably not the point; [Tomáš] simply created the WPU to do something out of the ordinary. It’s not meant to be a real, or even useful, CPU; it’s simply a thought experiment to see what is possible by twiddling bits around.
Tip ‘o the hat to [Adam] for sending this one in.
If you ever need to manipulate images really fast, or just want to make some pretty fractals, [Reuben] has just what you need. He developed a neat command line tool to send code to a graphics card and generate images using pixel shaders. Opposed to making these images with a CPU, a GPU processes every pixel in parallel, making image processing much faster.
All the GPU coding is done by writing a bit of code in GLSL. [Reuben]’s command line utility takes that code, sends it to the graphics card, and returns the image calculated by the GPU. It’s very simple for to make pretty Mandebrolt set images and sine wave interference this way, but [Reuben]’s project can do much more than that. By sending an image to the GPU and performing a few operations, [Reuben] can do very fast edge detection and other algorithmic processing on pre-existing images.
So far, [Reuben] has tested his software with a few NVIDIA graphics cards under Windows and Linux, although it should work with any graphics card with pixel shaders.
Although [Reuben] is sending code to his GPU, it’s not quite on the level of the NVIDIA CUDA parallel computing platform; [Reuben] is only working with images. Cleverly written software could get around that, though. Still, even if [Reuben]’s project is only used for image processing, it’s still much faster than any CPU-bound method.
You can grab a copy of [Reuben]’s work over on GitHub.