[Thomas] tipped us about his latest project: a stand-alone AVR programmer module named ISPnub. As you can see in the picture above, it is a simple circuit board composed of a main microcontroller (ATmega1284p), one button and two LEDs. Programming a target is a simple as connecting the ISPnub and pressing the button. The flashing operation success status is then shown using the green/red LED.
ISPnub gets its power from the target circuit so no external power supply is needed. It works over a wide voltage range: 1.8V to 5.5V. The module also features a programming counter which can be used to limit the number of programming cycles. A multi-platform Java tool is in charge of embedding the target flash contents with the ISPnub main firmware. The complete project is open source so you may want to check out the official GitHub repository for the firmware and the project’s page for the schematics.
[ZigZagJoe’s] first foray into astrophotography is this impressive AVR barn door tracker, which steps up his night sky photo game without emptying his bank account. If you’ve never heard of astrophotography, you should skim over its Wikipedia page and/or the subreddit. The idea is to capture images otherwise undetectable by the human eye through longer exposures. Unfortunately, the big ball of rock we all inhabit has a tendency to rotate, which means you need to move the camera to keep the night sky framed up.
Most trackers require precision parts and fabrication, which was out of [ZigZagJoe’s] grasp. Instead, he found a solution with the Cloudbait Observatory model, which as best as we can tell looks vaguely similar to the tracker we featured last year. Unlike last year’s build—which uses an ATmega32u4 breakout board— [ZigZagJoe’s] tracker uses an ATTiny85 for the brains, running a pre-configured table that determines step rate against time.
Continue reading “AVR Barn Door Tracker for Astrophotography”
If you have worked with very low cost microcontroller in the past, such as the ATtiny series from AVR, you’ve probably been stuck without a UART peripheral. The usual answer to this problem is to implement the UART in software. It’s not fast, but it works.
Lets say you’re even more limited on resources, and only have a single pin for UART. [Ralph] created a software library and a small circuit that enables half duplex UART using only one pin. With the above circuit, and a 62 byte Arduino compatible library, you can add UART to the tiniest of ATtinys.
In this circuit, the Tx/Rx pin is on the AVR, and the Tx and Rx pins are another device. The circuit relies on the idle state of UART being a logic high signal. When the Tx pin is idle, the transistor stays on. This allows the Tx/Rx pin to pull Rx low when the AVR sends a 0. When the Tx pin sends a 0, the Tx/Rx pin gets pulled low through the diode.
It’s a clever hack, and could definitely help add communication to your next tiny project.
[Ralph] has been working on an extraordinarily tiny bootloader for the ATtiny85, and although coding in assembly does have some merits in this regard, writing in C and using AVR Libc is so much more convenient. Through his trials of slimming down pieces of code to the bare minimum, he’s found a few ways to easily trim a few bytes off code compiled with AVR-GCC.
To test his ideas out, [Ralph] first coded up a short program that reads the ATtiny85’s internal temperature sensor. Dissassembling the code, he found the a jump to a function called __ctors_end: before the jump to main. According to the ATtiny85 datasheet, this call sets the IO registers to their initial values. These initial values are 0, so that’s 16 bytes that can be saved. This function also sets the stack pointer to its initial value, so another 16 bytes can be optimized out.
If you’re not using interrupts on an ATtiny, you can get rid of 30 bytes of code by getting rid of the interrupt vector table. In the end, [Ralph] was able to take a 274 byte program and trim it down to 190 bytes. Compared to the 8k of Flash on the ‘tiny85, it’s a small amount saved, but if you’re banging your head against the limitations of this micro’s storage, this might be a good place to start.
Now if you want to hear some stories about optimizing code you’ve got to check out the Once Upon Atari documentary. They spent months hand optimizing code to make it fit on the cartridges.
[Davide] saw our recent post on magnetic levitation and quickly sent in his own project, which has a great explanation of how it works — he’s also included the code to try yourself!
His setup uses an Atmega8 micro-controller which controls a small 12V 50N coil using pulse-width-modulation (PWM). A hall effect sensor (Allegro A1302) mounted inside the coil detects the distance to the magnet and that data is used by a PID controller to automatically adjust the PWM of the coil to keep the magnet in place. The Atmega8 runs at 8Mhz and the hall effect sensor is polled every 1ms to provide an updated value for the PWM. He’s also thrown in an RGB LED that lights up when an object is being levitated!
So why is there a kid with a floating balloon? [Davide] actually built the setup for his friend [Paolo] to display at an art fair called InverART 2013!
After the break check out the circuit diagram and a short demonstration video of the device in action!
Oh yeah, those of you not impressed by magnetic levitation will probably appreciate acoustic levitation.
Continue reading “AVR Atmega based PID Magnetic Levitator”
If you’re using an AVR microcontroller and you’d like to add USB to a project, there are a lot of options out there for you. Both LUFA and V-USB add some USB functionality to just about every AVR micro, but if you’d like a native serial port, your only options are to look towards the USB-compatible Atmel micros.
[Ray] looked at the options for adding a USB serial port and didn’t like what he saw; seemingly, this was an impossible task without a second, more capable microcontroller. Then he had an idea: if the goal is only to transfer data back and forth between a computer and a microcontroller, why not write an HID-class USB serial port?
[Ray] based his project on The V-USB library and created a new HID descriptor to transfer data between a micro and a computer. While it won’t work with a proper terminal such as Putty, [Ray] managed to whip up a serial monitor program in Processing that’s compatible with Windows, Linux and OS X.
In the video below, you can see [Ray] using an ATmega328p with a standard V-USB setup. He’s transferring analog values from a photoresistor as a proof of concept, but just about everything that would work with a normal serial port will work with [Ray]’s library.
Continue reading “Serial USB for Any AVR Microcontroller”
It’s not that breadboarding AVR circuits is difficult. But you have to admit that it takes some time to set everything up. We don’t label the top of our DIP chips so that you know what each pin does just by looking. Which means that wiring up the programmer involves pulling out the datasheet. [Vinnie] found the solution to this problem which is to make one of these interface PCBs for each AVR chip family. The long pins make it easy to drop over the top of your microcontroller, which is where the name comes from.
His first stab at the idea was just a hunk of home etched PCB which broke out the programming pins into the 6-pin ICSP standard. This second rendition uses the 10-pin standard and adds a few extras into the mix. He included decoupling capacitors which need to be used in every circuit anyway. There’s a crystal along with its load capacitors. This clock source is a snap to enable by burning some fuses. If you choose to use the internal oscillator instead this hardware won’t interfere. The LED is used to get you up and running with blinky firmware as quickly as possible. He plans to add jumper in the next revision which can disconnect this components from the I/O pin. Now you just need to add a 10-pin header to that USB keyboard AVR programmer and you’re in business.