Stian made this awesome sous-vide temp. controller, which he calls the “SousVide-O-Mator”. Built around an ATMega328 with the Arduino bootloader, it uses a DS18B20 temp. probe to monitor the temp, a 20×4 LCD to communicate with the user, and a solid-state relay to switch the rice cooker on and off. It also features one of the neatest, cleanest stripboard layouts I’ve ever seen (style counts!). He writes:
My brand spanking new homemade Sous Vide controller (PID controller for cooking). By connecting the relay to my rice cooker and putting the probe and a small aquarium pump inside I’m able to very accurately control the water temperature..
This is basically a heating immersion circulator as used by some fancy restaurants – readily made equipment cost in the range of $1000.. So I made one myself on the cheap (controller + rice cooker + water pump). This can be used to cook meat to perfection
This is an interesting native-USB hack. An atmel (1287?) with a microsd slot that ‘looks’ like an optical disk drive to allow booting. We think someone could probably hack this together using an our Atmega32u4 breakout board or Teensy, MicroSD breakout board, and a heavy dose of LUFA.
OK, so about a year or so ago, I was working at my bench and I could not quite see what I was doing. I needed more light! I got so mad, I built this in about a half a day, and fixed the problem. Now I have enough light even when working on tiny things with magnifiers on my head.
I now have 4 white 12″ CCFL tubes, 6 1 watt warm white LED’s, 144 cool white LED’s (in strips), and 12 5mm diffused white LED’s under the bench pointed at the floor (did you ever drop anything?). All the LED’s are ramped on and off with PWM dimming as you will see in the video above. I also have 2 more channels available with full PWM dimming. Running everything wide open will allow you to see very well, and only consumes 17 watts.
A little overkill, but I was really frustrated. And hey, who just wants a plain ole boring switch anyway? Not me…
You can never have enough lights on your bench!
UPDATE: Jeremy has made a new explanatory video (above, bottom), and shared his source code. You can check out all that new goodness here.
Check out these photos by Travis Goodspeed of an ATTiny45V chip die. It’s bigger sibling, the ATTiny85V, is used in the TV-B-Gone kit, and would look very similar, except for more memory. (I believe) the homogenous rectangles left of center in the top picture are the Flash modules.
Travis has been taking die photos for quite some time, and has a rather impressive set on Flickr. See also his “chip logos” set and his “chip artwork” set.
When hackers from penetration testing firm Netragard were hired to pierce the firewall of a customer, they knew they had their work cut out. The client specifically ruled out the use of social networks, telephones, and other social-engineering vectors, and gaining unauthorized physical access to computers was also off limits.
Deprived of the low-hanging fruit attackers typically rely on to get a toe-hold onto their target, Netragard CTO Adriel Desautels borrowed a technique straight out of a plot from Mission Impossible: He modified a popular, off-the-shelf computer mouse to include a flash drive and a powerful microcontroller that ran custom attack code that compromised whatever computer connected to it.
For the attack to work, the booby-trapped USB Logitech mouse had to look and behave precisely the same as a normal device. But it also needed to include secret capabilities that allowed the mouse to do things no user would ever dream possible.
The Teensy microcontroller programmed by the Netragard hackers was programmed to wait 60 seconds after being plugged in to a computer and then enter commands into its keyboard that executed malware stored on the custom-built flash drive snuck into the guts of the Logitech mouse. To squelch warnings from McAfee antivirus, which was protecting the customer’s PCs, the microcontroller contained undocumented exploit code that subverted the program’s dialogue boxes to evade detection.
Bit banger is built around an ATtiny15 microcontroller, which runs at 1.6 MHz and has 1 kB of flash ROM and a claustrophobic 32 bytes of RAM. In fact, those 32 bytes are the CPU registers. Only the most basic AVR instructions are supported; they occupy at least two bytes each, and can obviously not be compressed since they are executing from ROM, so a maximum of 512 instructions will fit inside the chip (fewer if static data is needed).
The microcontroller supports interrupts, but they would have been too costly to use. Instead, the entire demo is cycle counted.
At a clock rate of 1.6 MHz, the visible part of each line of the VGA signal swooshes by in exactly 36 clock cycles. The entire line, including horizontal blanking, is 51 clock cycles wide. During this time, both graphics and sound must be generated.
I quickly arrived at the following overall design: Three registers make up a 24-bit frame buffer, organized as a 3×8 grid. Every 60 raster lines, these registers are rotated one bit, to prepare for the next row of the grid. At three different positions along the visible part of the line, the MSB of the corresponding frame buffer register is interpreted as an instruction to either keep or invert the current colour; the resulting colour is then transmitted onto an output pin. At the end of the visible line, black is selected.
In the gaps between these four positions and the two places where the horizontal sync signal is flipped, sound must be generated and emitted. The ATtiny15 luckily has a PWM output that runs on a separate peripheral clock at a staggering 25.6 MHz, which is high enough for 8-bit audio output. Writing a sample to the PWM output is a simple one-cycle instruction; the challenge is to calculate the value of the sample during the remaining clock cycles.
hardcore+BA, and the song is a straight-up jam. Happy Friday!
A while ago I helped make a light that lit up when a near Earth asteroid went past our planet. Because I built it at a 24 hour hack day, I only had a little bit of time and there was a lot of ‘crafting’ involved (read: hot glue and plastic cups). Unfortunately I never really worked it into a finished product. This was partly because I noticed how rarely an asteroid actually buzzes the Earth close enough to be interesting. It got me thinking though, what else might I want to know about, and that happens often enough to be interesting?
The International Space Station (ISS) is a marvel of current technology and humanity. It’s a continuously inhabited orbital outpost, floating in space just over our heads. But often we forget it’s there. I realized that the light I made for asteroids would work better for the space station.
Microtouch – 2.4, make your own “iTouch-like” device! Sure, the latest “iTouchy” gadgets are pretty cool. But who wants a locked down device? Why not build your own touch-screen device, with your own apps, all on open source hardware and using open source tools? OK, it can’t play MP3s, but it does have a 320×240 TFT color display with resistive touch screen, an Atmega32u4 8-bit microcontroller, lithium polymer battery charger, backlight control, micro-SD slot, and a triple-axis accelerometer. Yeah, this is the next big thing and for those of us who like to DIY, you can do a lot of cool stuff with this dev board.
This product is just the Microtouch dev board (preloaded with some demo Apps), and does not include a lithium polymer battery or a microSD card. You will need a lipoly battery with 2-pin JST connector for best performance. It can run straight from USB but due to the charger design, the backlight will be dimmed so it will not appear as bright as with a battery installed. We strongly suggest our medium lipoly but you can substitute another 3.7V cell. A microSD card will be handy if you want to display images, slideshows or animations.
2.8″ 320×240 16-bit color, TFT display with resistive touch screen
Lithium polymer battery charging via USB
3-axis accelerometer, MMA7544 +-2g to +-8g resolution
Micro SD card slot
Battery monitoring, backlight control and on/off switch
Of course, we wouldn’t just leave you with a schematic or datasheet and say ‘good luck’! The designer of the Microtouch (known to us by the code name “Rossum” ) has written a full hardware core operating system and multiple demo apps such as…
Image viewer built into the hardware core, you can plug in a microSD card with images, slide shows or animations that show up as ‘mini Apps’
The Microtouch is powerful and fun but is not meant for microcontroller beginners! If you’re just starting out, we suggest checking out the Arduino to get your feet wet. Once you feel comfy with programming C and programming microcontrollers directly, come back and pick up one of these.
Here is a short video of a CNC hot wire foam cutter that is being controlled with an AtMega32u4 breakout board. It was programmed using the Arduino IDE by pressing the reset button and clicking on “upload” a second later. I have to make a few more videos providing details. I was surprised at how much the little thing could do; thanks for making such a fun little board.
Build instructions for the ‘Baby Interface Device’ (BID), an ultra-simple USB Human Interface Device for Tiny Humans. Built to allow my kid to interact with the computer without destroying my keyboards. The BID is a DIY USB HID (Human Interface Device) that acts as a keyboard to trigger a single keypress (space bar in this case). The concept is to create a very large button that is baby-friendly to allow an infant to interact with computer games and educational software.
The project can be assembled in less than an hour for around $35 or less and requires very little knowledge of electronics or coding.
JeeLabs has a very informative post about memory usage on the ATMega, along with some Arduino sample code and an explanation of how bad memory management can cause sketches to fail. More from Jean-Claude:
Sometimes, it’s useful to find out how much memory a sketch uses.
Sometimes, it’s essential do so, i.e. when you’re reaching the limit. Because strange and totally unpredictable things happen once you run out of memory.
…
Running out of RAM space is the nasty one. Because it can happen at any time, not necessarily at startup, and not even predictably because interrupt routines can trigger the problem.
There are three areas in RAM:
static data, i.e. global variables and arrays … and strings !
the “heap”, which gets used if you call malloc() and free()
the “stack”, which is what gets consumed as one function calls another
The heap grows up, and is used in a fairly unpredictable manner. If you release areas, then they will be lead to unused gaps in the heap, which get re-used by new calls to malloc() if the requested block fits in those gaps.
At any point in time, there is a highest point in RAM occupied by the heap. This value can be found in a system variable called __brkval.
The stack is located at the end of RAM, and expands and contracts down towards the heap area. Stack space gets allocated and released as needed by functions calling other functions. That’s where local variables get stored.
Check out his post for the code and further explanation.
Students in ECE 4760 at Cornell University were given the responsibility of choosing,designing and building a project using Atmel Mega644 microcontrollers.
Projects this year include a multitouch interface, face recognition system, and an automated rock band vocal player, as well as musical instruments and scientific devices.
During the last 5 weeks of the semester in ECE 4760,Microcontroller Design, students have to combine sensors, actuators, microcontrollers, and mathematical techniques to build something. All projects show a great deal of originality and work. There are over 380 projects on the page. This year the coding was done using WINAVR and AVRstudio.
Pulse Width Modulation (PWM) is a technique widely used in modern switching circuit to control the amount of power given to the electrical device. This method simply switches ON and OFF the power supplied to the electrical device rapidly. The average amount of energy received by the electrical device is corresponding to the ON and OFF period (duty cycle); therefore by varying the ON period i.e. longer or shorter, we could easily control the amount of energy received by the electrical device. The Light Emitting Diode (LED) will respond to this pulse by dimming or brighten its light while the electrical motor will respond to this pulse by turning its rotor slow or fast.
John Boxall (tronixstuff) wanted to know just how long the EEPROM in an ATMega328 would last, so he whipped up this neat test program to stress the memory. He writes:
Some time ago I published a short tutorial concerning the use of the internal EEPROM belonging to the Atmel ATmega328 (etc.) microcontroller in our various Arduino boards. Although making use of the EEPROM is certainly useful, it has a theoretical finite lifespan – according to the Atmel data sheet (download .pdf) it is 100,000 write/erase cycles.
One of my twitter followers asked me “is that 100,000 uses per address, or the entire EEPROM?” – a very good question. So in the name of wanton destruction I have devised a simple way to answer the question of EEPROM lifespan. We will write the number 170 (10101010 in binary) to each EEPROM address, then read each EEPROM address to check the stored number. The process is then repeated by writing the number 85 (01010101 in binary) to each address and then checking it again. The two binary numbers were chosen to ensure each bit in an address has an equal number of state changes.
After both of the processes listed above has completed, then the whole lot repeats. The process is halted when an incorrectly stored number is read from the EEPROM – the first failure. At this point the number of cycles, start and end time data are shown on the LCD.
The result? 1,230,163 write/read cycles (per address) before failure. That’s an order of magnitude+ beyond Atmel’s specs, though Atmel does tend to be conservative with their numbers.
Taylan ran into a problem with a DIY ATmega168p Arduino kit not having the required bootloader for proper use. Come to find out he was able to figure out how to use his Bus Pirate within the Arduino IDE.
This morning an idea popped up in my mind to use the Bus Pirate with avrdude. I managed to program but something was off because I was not able to connect to the bootloader. I can use Bus Pirate with avrdude directly as it’s firmware can interact with avrdude. “How about embedding it into Arduino IDE?” was the question in my mind now.
While messing around the directory of Arduino IDE, I found some text files and answer to my question lies in one of them: programmers.txt
Just add these three lines to it and you are good to go (note: you might need root privileges for Linux)
buspirate.name=The Bus Pirate buspirate.communication=serial buspirate.protocol=buspirate
The Bus Pirate is a wonderful tool to have on hand and you can pick up your own in the Adafruit Store.
Printable catalog (PDF)
FEED
