[Martin Melchior] wanted to use an older Sigma lens with his Canon camera. The problem in trying to do so is that the camera uses a different communications protocol than the lens is expecting. But if you don’t mind cracking it open and doing a little microcontroller work you’ll be using the lens in no time.
The hack uses an ATtiny24 chip, two resistors, and a capacitor. You won’t need to do any coding, but you do need to burn the firmware to the chip (you can use an Arduino if you don’t have a proper AVR programmer). There’s plenty of room for the add-on hardware inside the lens so after reassembling the enclosure you won’t even be able to tell that the unit was altered. Unfortunately it doesn’t look like [Martin] took any pictures of the lens with his added electronics, but the schematic he posted should be enough for you to get the job done yourself.
If you’re into these types of DSLR hacks you should try something extreme, like using view camera parts with your modern camera.
Here’s a way to play around with simple computing concepts without going too crazy with the hardware side of things. [John Eisenmann] calls it the DUO tiny. It’s a programmable computer based around the ATtiny84. He wrote the operating system himself, building in a set of commands that make it quite functional, but allow the user to manipulate or even write the programs using the four button interface. Editing and running programs (which include some games) is demonstrated in the clip after the break.
The three major components used in the system are the ATtiny84, and EEPROM chip with 64 KB capacity to hold the programs, and the 102×64 pixel LCD screen seen above. The project began on a breadboard, but as he brought each part into being it transitioned to a strip-board prototype and finally this fab-house version.
Continue reading “Programmable computer built from a humble ATtiny84”
[Michael] built his own LED marquee using individual diodes. Despite his choice to forego the 8×8 or 5×7 modules we often see in these projects, his decision to spin a dedicated PCB saved him a lot of trouble during assembly. Sure, he still had to solder 180 leads on the 9×18 grid of lights, but at least he didn’t have to deal with wiring up the complex display layout.
The chip driving the display is an ATtiny24. You can see that it’s an SMD package and spans one row of the through hole LED footprint. There are way too few pins to drive a multiplexed display of this size. Instead of adding a separate driver IC he decided to design the display to use Charlieplexing. We didn’t see a schematic for the project, but judging from the board images all of the I/O pins are used by either the display itself, or the serial connection provided by that right angle pin header.
If you don’t mind working with really small components this POV wheel project for a longboard will certainly attract some attention.
The name of the game here is small and cheap. Small because the wheels are only 72mm in diameter (about 2.8 inches). Cheap because [Ch00f] wants to produce and sell them locally. He went with an ATtiny24 microcontroller driving fifteen LEDs. Obviously this will present a problem as the uC uses a 14-pin SOIC package and that’s just not enough I/O to drive the LEDs individually. Add to that the issue of storing patterns to be displayed and you start to run out of program memory very quickly.
But obvious he pulled it off. The image above shows the wheel displaying the CT logo (for ch00ftech.com) and there are several other patterns shown off in the clip after the break. The LEDs are multiplexed, but the wheel spins fast enough that this turns out to be okay. The rotation is measured by an IR reflectance sensor aimed at the stationary axle. A CR2032 powers the device, with some counterweights added to keep the wheel balanced.
Our only concern is the fragility of the exposed electronics. But if you hit the right BOM price we guess you can just replace the board as needed.
Continue reading “POV wheels for a longboard”
[Blark] took a few parts and turned them into a simple scoreboard. The centerpiece of the build is a set of 4″ seven-segment displays. With those in hand it was just a matter of choosing a controller to feed them data, and developing a user interface.
He seems to have had some issues as he mentions having blown up two PIC chips while soldering. He transitioned to an ATtiny24 chip and everything seems to work quite well now. The user interface depends on two buttons, each increments the score for one half of the display and pushing both at once zeros the game score. The displays use shift registers to store data so they’re quite easy to control with AVR chips. Check out the demo video after the break.
The only problem here is that someone needs to be on the sidelines to increment the score. We’ve seen some more intricate designs that let you use a remote control or even a smart phone.
Continue reading “4″ seven segment displays make a fine scoreboard”
Tinywrench is [Tanjent’s] take on a motor controller board. It aims to replicate all of the functions that a standalone motor controller chip offers at as low a cost as possible. Early results are in. It works, and as seen can be assembled for about $8.
The top of the device offers a terminal block for connecting motors, ground, and 24V input. A pin header on the bottom has all the connections you would expect to find with a stepper motor driver board. Looking back on top there’s also a pair of ATtiny24 chips, each with its own trimpot for balancing the constant current output. Hiding on the underside of the board are two H-bridges built using high and low-side MOSFETs along with some diodes for protection, and various passive components for driving them.
As it stands, each of those H-bridges can handle around 9 amps which should be more than enough for projects with small motors. [Tanjent] mentions that one of the main advantages of working with this instead of a single motor-driver chip is that if you fry one of the MOSFETs you can replace it instead of trashing the entire board.
[Tom] recently started experimenting with Charlieplexing, and wrote in to share the 4x4x4 cube he built with an ATtiny24. Similar to this minimalist 4x4x4 LED cube we featured the other day, [Tom’s] version attempts to use the least pins possible to drive the LEDs, but in a different manner.
[Tom] didn’t want to sacrifice brightness, so he decided that the LEDs would have a 1/8 duty cycle. The problem is that the ATtiny’s I/O ports can’t support that kind of current so he needed a different means of driving the LEDs. Rather than employ any sort of shift register to control the LEDs, he opted to exclusively use transistors as he had done in previous projects.
For his Charlieplexed cube to use a total of 9 I/O pins he had to get creative with his design. He broke each level of the structure into two non-connected groups of LEDs, utilizing diagonal interconnects to get everything wired up properly.
It seems to work quite nicely as you can see in the video below. While it uses two more I/O lines than the other ATtiny cube we featured recently, we love the simple, shift register-less design.
Continue reading “ATtiny Hacks: ATtiny-controlled 4x4x4 LED cube has a unique design”