Benny Hill Chase Music :: AVR Freaks. ftkalcevic writes -

Ok, this is an embarrassing problem. I’m using AVR Studio 6.1 beta (6.1.2440), and about every 5-10 times I build my solution, the Benny Hill chase music starts playing! I have visual studio 2010, and it doesn’t do it. I’ve googled for viruses, but found nothing. Windows defender found nothing. (My box is pretty well locked down – I don’t run as administrator). It seemed to start happening after I installed the LUFA via the gallery – this may be a coincidence. Have I found an easter egg? Can it be turned off?

Charlieplexing LEDs with an AVR ATmega328 (Arduino). Andy writes -

I’m working on a little timekeeper project that works similarly to those word clocks, but it will be wrist-mounted. I have to make this little guy tiny, so I’m going with all SMD and to light the 21 LEDs, I’m using a 5-pin Charlieplexing scheme. To give back to the community (and FWIW), I am writing up my understanding of and methods for implementing Charlieplexing on an Atmel ATmega328 AVR (or Arduino). This first part of the 2-part series goes over the concept of Charlieplexing. The second article will show my homemade quality control methods and Arduino and AVR C code. I hope someone finds the write-up useful!

Hack It Better: Apple Extended Keyboard II @ iFixit.

I’m lucky enough to own an Apple Extended Keyboard II, which belongs to my Macintosh SE. Unfortunately, it wasn’t doing much good connected to my rarely-used SE. So, I figured it would find a better home on my desk at work, where I spend the day pounding away on a crummy keyboard anyway.

The Apple Extended Keyboard II is a dream to type on because it uses mechanical switches. And I lucked out: Apple made a lot of revisions of this keyboard with cheap switches, but it turns out that I got one of the good ones. Mine is a USA model with authentic Alps Cream key switches.

The biggest stumbling block to the project was the computer’s interface. The Apple Extended Keyboard II is from the days of ADB, or Apple Desktop Bus. The internet revealed two possible solutions: An expensive and sometimes-hard-to-find adapter by Griffin, or a $16 microcontroller and some DIY elbow grease. Naturally, I chose the latter.

Hack! USB NeXT Keyboard with an Arduino Micro @arduino #arduino #NeXT.

Ladyada and pt had an old NeXT keyboard with a strong desire to get it running on a modern computer. These keyboards are durable, super clicky, and very satisfying to use! However, they are very old designs, specifically made for NeXT hardware:, pre PS/2 and definately pre-USB. That means you can’t just plug the keyboard into a PS/2 port (even though it looks similar). In fact, I have no idea what the protocol or pinout is named, so we’ll just call it “non-ADB NeXT Keyboard”

There is no existing adapter for sale, and no code out there for getting these working, so we spent a few days and with a little research we got it working perfectly using an Arduino Micro as the go between. Now this lovely black deck works like any other USB keyboard. Sure it weighs more than our Macbook, but its worth it!

ReAD MoRE!

AVRDUDESS is a GUI for AVRDUDE, a tool for programming Atmel microcontrollers.

Some key features:

• Supports all programmers and MCUs that AVRDUDE supports
• Supports presets, allowing you to change between devices and configurations quickly and easily
• Drag and drop files for easy uploading
• Automatically lists available COM ports

Learn more and download here.

Trammell Hudson made this motherboard for the Tandy TRS-80 with a Teensy++.

Want to be featured on Flickr pool Friday? Add your Adafruits to the Adafruit Flickr pool.

Trammell also visited Adafruit HQ last week along with M. Elizabeth Scott!

little-scale writes:

The aim of this post is as a starting point for making your own DIY MIDI controller. Although many MIDI controllers can be purchased off the shelf, there may be times when a DIY approach is more economical or more appropriate in terms of specific design and mapping.

This is one of the simplest MIDI controllers that I can think of – it is just a pot (i.e. “knob”) that sends USB MIDI continuous controller data on CC#1, channel 1.

Hardware needed:
• 1 x Teensy board with pins
• 1 x USB A to B mini cable
• 1 x 100kΩ B-type potentiometer
• 1 x mini breadboard
• 3 x breadboard jumpers (can use a jumper kit for instance)

Software needed:
• Arduino IDE
• Teensyduino
• A digital audio workstation (DAW) such as Ableton Live

The Teensy is a complete USB-based microcontoller development system, in a very small footprint! All programming is done via the USB port. No special programmer is needed, only a standard “Mini-B” USB cable and a PC or Macintosh with a USB port. This is the latest version, 2.0.

Key Features:

• USB can be any type of device
• AVR processor, 16 MHz
• Single pushbutton programming
• Easy to use Teensy Loader application
• Free software development tools
• Works with Mac OS X, Linux & Windows
• Tiny size, perfect for many projects
• Available with pins for solderless breadboard

Comes with assembled Teensy board (ATmega32u4 with bootloader preinstalled) and header to allow easy breadboarding. We suggest using AVR-gcc (like WinAVR) with the LUFA library or ‘Teensyduino’ Be sure to check out the multiple resources available at PJRC!

Teensy 3.0 is a 32 bit ARM-based, breadboard compatible development board that you can program using the Arduino IDE.  Teensy 3.0 runs sketches much after than 8 bit Arduino boards, has higher performance peripherals, and is available at Adafruit now.

I’m Paul Stoffregen, creator of the Teensy board and software.  Phil Torrone asked me to share some of the details of making Teensy 3.0 here on the Adafruit blog.

Click “read more” for details of the latest software update, real-time clock support, touch sensing, bugs recently fixed, development on the XBee, SdFat and FastSPI libraries, and some discussion of issues porting Arduino libraries to run on a 32 bits processor, and remaining challenges to be addressed in the next software updates.

Software Update, Beta #6

As of today, the sixth Teensy 3.0 beta test software is now available.  Here are the links.

http://www.pjrc.com/teensy/beta/arduino-1.0.1-teensy3-beta6-linux32.tar.gz

http://www.pjrc.com/teensy/beta/arduino-1.0.1-teensy3-beta6-linux64.tar.gz

http://www.pjrc.com/teensy/beta/arduino-1.0.1-teensy3-beta6-macos.zip

http://www.pjrc.com/teensy/beta/arduino-1.0.1-teensy3-beta6-windows.zip

This version adds a few important features and fixes several bugs.

Real-Time Clock Support

This software release provides support for Teensy 3.0′s on-chip RTC.  To use it, you’ll need to solder a 32.768 crystal to the board.  A 3 volt coin cell is optional, but without the battery the RTC will lose track of the date and time when power is turned off.

The recommended crystal is Digikey 300-8303-ND.  Any similar 32.768 kHz, 12.5 pF crystal should work.  The crystal can be placed on either side of the board, but I highly recommend soldering from the bottom side, to avoid accidentally touching or solder bridging to any of the tiny top-side parts.

To access the clock, use these 3 functions:

Teensy3Clock.get()
Teensy3Clock.set(atime_t)
Teensy3Clock.compensate(num)

The set() function sets the time, using a 32 bit unsigned integer.  The common convention is the number of seconds elapsed since 1970.  The RTC simply increments the number every second.  The get() function gives you the current time.

Once the RTC is running, uploading new code does not reset it.  You can click Upload in Arduino over and over, without losing the current time.  If a battery is connected, the time will be maintained while power is off.

The compensate() function lets to adjust the speed of the clock slightly.  If it’s running too fast, call compensate() with a negative number to slow it down a bit.  The adjustment is approximately the ppm/8.  If you use compensate(-40), the clock is slowed by 5 ppm (parts per million).

If you know how your crystal response to temperature, you could measure the temperature with analogRead(38) and use the results to change the crystal compensation as the temperature changes!

These 3 functions alone aren’t very usually very interesting.  To handle time and date in hours, minutes, seconds, days, months and years, Michael’s Margolis’s Arduino Time library is very helpful.  The get() function is intended to be used with Time’s setSyncProvider().  In File > Examples > Time > TimeTeensyRTC is a simple example.

Over the last few days, Michael and I have talked about how to port his Time to ARM.  The Time library included in this software release is a preliminary port.  It should work well, but please be aware future versions may change slightly.

Touch Sensing

The touchRead(pin) function is finally implemented.  It works similarly to analogRead(pin).  Just call the function with one of the pins that has touch sensing, and it will return a 16 bit number representing the capacitance on that pin, in 1/50th pico-Farad units.  If the pin has 40 pF, you’ll get 2000.

The measurement is the capacitive coupling to ground.  For human touch interfaces, the best results are when the person’s body is physically connected to ground.  With hand-held devices, usually the enclosure has exposed metal for this purpose.  It still works reasonably if Teensy’s ground is connected to earth ground, usually through the USB cable.  But running from a battery (called “floating”) or connected to a laptop computer running from its battery doesn’t work well.

Of course, it’s possible to implement capacitive sensing using ordinary pins.  The CapSense library does it quite well.  But Teensy 3.0′s built-in hardware gives you 3 things you can’t get from software-based capacitive sensing.

1: Sensitivity:  By default, touchRead() gives 0.02 pF sensitivity.

2: Speed: The measurement time depends on the capacitance.  A worst-case measurement takes about 5 ms.  Typical capacitances used for human touch typically read much faster.  Even when cycling through all the touch sensitive pins, you get excellent sensitivity at very responsive speeds.

3: Stability: The measurement works by comparing the pin’s capacitance to an on-chip reference capacitor.  If the power supply voltage, charging and discharging currents or other electrical factors change, their effect on the measurement are largely canceled out by using the same on-chip hardware to measure both the pin and the reference capacitor.

The common use is to replace buttons and sliders with touch-sensitive controls.  But with 0.02 pF sensitivity, perhaps touchRead() can be used for other very interesting projects?

Bugs Fixed Since Beta #5

Reproducible bugs reports really, really help.  Most of the bugs fixed in this release are due to bug reports I received.

The SPI.setClockDivider() but reported by John and Thomas is fixed.

Many missing files were added, and minor edits made, so Ethernet now compiles.  So far, Ethernet is untested on Teensy 3.0.  If you do try Ethernet, please keep in mind the Wiznet W5100 chip draws more than the 100 mA current Teensy 3.0 can provide on the 3.3 volt pin.  An external regulator or source of power for the W5100 is needed.

I added wiring_private.h, prog_uchar() and other things needed for Adafruit’s ST7735 and Adafruit_GFX libraries, as reported by Joh Lummel.  Sadly, there is still a remaining linker error.  If anyone has insight into this problem, please contact me.

I added the missing digitalPinToTimer() function needed by the alternate LiquidCrystal library, as reported by Kgrider.  This library is still untested, but it now compiles and looks like it should work.

A file naming bug preventing the EEPROM library from working on non-Linux systems was fixed.  Thanks to Alex Ferro for reporting this.

XBee Library

I sent a small XBee library patch to Andrew Rapp.  It was failing to compile because it assumed “Serial” is of type “HardwareSerial”.  On Teensy, Serial is a USB virtual serial.  The same is true on Arduino Leonardo.  The patch allows XBee to work on both boards.

Andrew and I exchanged a few messages.  Many people have wanted to use the XBee library with the software serial library.  Even though it’s not very useful for Teensy 3.0 (which has 3 real hardware serial ports), I created a patch for XBee to allow use of software serial, or any Arduino Stream compatible library.

Andrew published the code as a 0.4 beta test.  If you’re using an XBee on a regular Arduino board, please give a try and send Andrew some feedback.

http://code.google.com/p/xbee-arduino/

SdFat Library

Beta 4 was the first version to support the SD library (not impacted by the SPI.setClockDivider bug).

Since beta 4, I’ve exchanged several messages with Bill Greiman, author of the SdFat library.  Bill has been working on a newer, faster versions.  The one that comes with Arduino is fairly old.  He sent me a beta test version, and a patch to make it compile in the 32 bit environment.

Teensy 3.0′s SPI port is capable of 24 Mbit/sec speed.  That’s 3 times faster than the AVR-based Arduino.  It also has a small FIFO and DMA transfer capability.  My initial support for the SD library involved emulating the AVR SPI port.  I spent a couple days fiddling with native routines, which admittedly were probably only a start at a truly native solution.

Bill optimized the native code and put it in his faster library.  Here is a benchmark result he posted.

http://arduino.cc/forum/index.php/topic,121568.msg959812.html#msg959812

I should mention this is probably not even “beta” code at this point.  It’s also worth keeping in mind the speeds vary quite a bit from one SD card to another.

Still, it’s pretty exciting seeing such impressive read and write speeds.  This could really open up a lot of amazing project possibilities.

FastSPI Library

I also spent some time talking with Daniel Garcia (author of the FastSPI library) and Mark Kriegsman, about driving huge numbers of RGB LEDs.  Last weekend they worked with a couple Teensy 3.0 boards, and got them driving LEDs.  Here’s a photo Mark sent of the first light, on October 14, 2012:

Later that day, Dan had a strip of 160 LDP8806 LEDs refreshing at 1300 frames/sec. Since then, I’ve heard he has some preliminary support for Teensy 3.0 in the library.  I believe some pretty exciting LED driving projects are likely to happen!

I’m personally very interested to try using combinations of DMA channels to synthesize the special waveforms needed by some of 1-wire the addressable RGB LED driver chips.  That’s a complex topic that could fill a huge posting all by itself. For now, it’s taking every ounce of self-restraint I have to resist the RGB LED urge….

Issues Running 8 Bit AVR Code on 32 Bit ARM

Since I started working on Teensy 3.0 over a year ago, and especially in the recent months as more people have heard about the project, I’ve regularly been asked what types of problems arise when adapting 8 bit Arduino code to a 32 bit platform.

So far, there are been remarkably few issues involving the different size of int, pointers and other basic data types.  Most code is really quite well written.  The relatively small number of issues are usually caught by the compiler.  But one turned up today….

Jonathan Sorensen reported a problem that turned out to be code that compiles without error, works on 8 bit AVR, but fails when run on 32 bit ARM.  It’s a library from Pololu for their LSM303-based Inertial Measurement Unit.

Here is the code.  a.x is a float, and xha and xla are bytes from an accelometer.  Can you spot the bug, without peeking at the explanation below?

a.x = (xha << 8 | xla) >> 4;

The 2 bytes, xha and xla, were read using the Wire library.  Together they form a 2′s complement number.  This code reassembles the 2 bytes, divides by 16, and then assigns the result to the float.

Both AVR and ARM combine the two halves to the correct 16 bit result.  The hidden gotcha is the right shift operation.  You might expect this to simply shift the bits to the right, but what goes into those “empty” most significant bits?  It’s not necessarily zeros.  On AVR, it’s handled as a signed integer, so if the number is negative, the left-most 1 bit is replicated to the 4 empty bits.

On ARM, it’s also handled as a signed integer.  But instead of an integer with a range of -32786 to +32767, it’s an integer with range -2147483648 to +2147483647, which happens to be using a small 0 to 65535 portion of that huge 32 bit range. When the sensor reads positive, the result is correct.  But when negative, the result is a wrong positive number.

Even without the right shift, the same problem would occur while converting the integer to a float (and does indeed happen elsewhere in this library).  To the compiler, the unsigned logical or only becomes a signed integer if the result exactly matches the size of the result.  A type cast is needed, so the desired 16 bit signed integer is always used.

a.x = (int16_t)(xha << 8 | xla) >> 4;

Normally, even code that packs bytes into large variables works fine.  But depending on sign extension from an intermediate result with implicit type is a hidden gotcha, which probably isn’t obvious to many programmers.

Missing Features, Coming Soon….

At the top of my to-do list are 2 of the missing USB Types: Keyboard/Mouse/Joystick and MIDI.  Teensy 2.0 supports these, and several others.  In time, I’ll do them all on Teensy 3.0, plus a few more I have planned.

Also extremely urgent is an AVR-like ISR() macro and interrupt vector table scheme. Since beta 2, attachInterrupt() has worked.  But if you want to use any of the interrupts directly, the only way to do so is editing the table in mk20dx128.c. Soon I’m going to rework that file and the linker script, to support a system that look and works very much like what everyone is used to on AVR.

While testing SdFat, Bill Greiman discovered problems with malloc/free.  He sent me a very detailed, very helpful description.  It turns out the newlib library malloc was designed for and defaults to settings that make sense for a large memory system.  It requests memory in 4K blocks, which is very large for such a small microcontroller.  I’m going to try porting or reimplementing the avr-libc malloc/realloc/free system, with minor modification for 32 bit word alignment.

The other item on my urgent to-do list, which probably needs some explanation, is Arduino reset emulation.  Traditionally, Arduino has used a 2 chip design, where the USB to serial converter is a dedicated chip.  When you open the Arduino Serial Monitor, the change on the DTR signal resets the AVR chip, causing your program to restart a fraction of a second after the serial monitor window appears.  It’s a very convenient feature (though some people might prefer their board never automatically reset).  Lots of Arduino sketches and library example depend upon this automatic reset behavior.

For years, Teensy 2.0 has emulated this 2-chip reset behavior, using only a single chip.  It’s tricky.  Interrupt-based code parses a restart request, which is sent as the serial monitor window is opening (Teensy doesn’t use DTR, so it the auto-reset isn’t easily happen by accident while using non-Arduino software).

Microsoft’s driver has terrible bugs which are triggered if the device instantly resets before the request is acknowledged, or before a couple more followup requests also complete successfully, so a software-based timer is started.  When the timer elapses, a reset is simulated by shutting down all the on-chip peripherals and jumping back to location 0.  But the USB port is left operating, as if nothing happened.  Then the USB initialization code checks to see if the USB is already running.  If it is, an alternate initialization is done.  If not, the USB is initialized.  All the critical USB state variables are located in a special “noinit” memory section, so the C runtime startup code doesn’t overwrite them.  When actual cold USB startup is done, they all have to be written, even if they’re zeros.

If that sounds like an overly complex implementation for a minor feature, perhaps it is?  But years of experience with Teensy 2.0 shown it really makes a big difference in usability.  It’s also really convenient.  I’m going to implement it in Teensy 3.0 soon.

I hope you’ll have a great time using Teensy 3.0.

-Paul

NEW PRODUCT – Teensy 3.0 + header. Teensy 3.0 is a small, breadboard-friendly development board designed by Paul Stoffregen and PJRC. Teensy 3.0 will bring a low-cost 32 bit ARM Cortex-M4 platform to hobbyists, students and engineers, using an adapted version of the Arduino IDE (Teensyduino) or programming directly in C language.

Based on a 32 bit ARM chip, Teensy 3.0 aims to greatly increase the computing capability and peripheral features, but maintain the same easy-to-use platform that has made Teensy 2.0 so successful.

Please note: Teensy 3.0 and 2.0 are not official Arduino-brand products. Although the Teensyduino IDE has been adapted so that many simple Arduino projects will work with the Teensy, there will still be a lot of libraries and shields that will not work with this device! If you’re new to microcontrollers, we suggest going with a classic Arduino UNO since all Arduino projects, examples and libraries will work with it.

Technical Specifications:

• 32 bit ARM Cortex-M4 48 MHz CPU (M4 = DSP extensions) Here is Freescale’s datasheet for the chip (warning 1227 pages)
• 128K Flash Memory, 16K RAM, 2K EEPROM
• 14* High Resolution Analog Inputs (13 bits usable, 16 bit hardware)
• 34* Digital I/O Pins (10 shared with analog)
• 10 PWM outputs
• 8 Timers for intervals/delays, separate from PWM
• USB with dedicated DMA memory transfers
• 3 UARTs (serial ports)
• SPI, I2C, I2S, IR modulator
• I2S (for high quality audio interface)
• Real Time Clock (with user-added 32.768 crystal and battery)
• 4 general purpose DMA channels (separate from USB)
• Touch Sensor Inputs

This board is super new, so most of the information, documentation and specs are only up on the Kickstarter page. Please check it out for more details!

In stock and shipping now!

USB Analog Gauge @ NYC Resistor. Hudson writes -

Perhaps at your hackerspace you have a pile of “badass gauges” and want to do something with them. How about a USB interface, a laser cut enclosure and an RGB status indicator LED?

Uses a Teensy!

SevenBlocks – A Tribute to Seven Segments

SevenBlocks is a digital clock resembling a classic red on black alarm clock, featuring a mechanic seven segment display of solid blocks moving into the viewers space. Over a hundred years ago the seven segment display was born and they became ubiquitos in our daily lifes. Thousands of segments are guiding us throughout our life, without us spending a single thought on this beautiful invention.

SevenBlocks is a digital clock resembling a classic red on black alarm clock, featuring a mechanic seven segment display of solid blocks moving into the viewers space.

Ingredients: ATMega8, HXT-500, Acrylic glass, 75HC595, DS1307, DCF77,LM75, …

See https://github.com/kiu/SevenBlocks for Bill Of Materials, DXF files, Eagle/Gerber files and source code.
- All files are licensed under Creative Commons Attribution 3.0 (CC BY 3.0)

Trammel Hudson writes:

My project with Adam Mayer at NYC Resistor to read every PROM that we find continues into its fourth version. The latest is most compact and flexible yet — the entire design piggybacks a pjrc Teensy++ on the 40 pin DIP ZIF socket from Adafruit Industries with almost no wiring and is super flexible. It can reroute the pins in software, so most any five volt DIP ROM, EPROM or EEPROM can be read.

via Facebook

Teensy++ (AT90USB1286 USB dev board) + header! The Teensy++ is a complete USB-based microcontoller development system, in a very small footprint! All programming is done via the USB port. No special programmer is needed, only a standard “Mini-B” USB cable and a PC or Macintosh with a USB port. Its the big sister version of the popular Teensy board we carry, this board has tons of FLASH, RAM, pins and more. This is the latest version, 2.0.

Key Features:

• USB can be any type of device
• AVR processor, 16 MHz
• Single pushbutton programming
• Easy to use Teensy Loader application
• Free software development tools
• Works with Mac OS X, Linux & Windows
• Tiny size, perfect for many projects
• Comes with headers pins that you can solder on to plug it into any solderless breadboard

Comes with assembled Teensy++ board (AT90USB1286 with bootloader preinstalled) and header to allow easy breadboarding. We suggest using AVR-gcc (like WinAVR) with the LUFA library or ‘Teensyduino’ Be sure to check out the multiple resources available at PJRC!

Dimensions: 2″ x 0.7″

• FLASH: 130048 bytes available
• RAM: 8192 bytes
• EEPROM: 4096 bytes
• IO: 46 pins
• ADC: 8 analog inputs (multiplexed to one ADC)
• PWM: 9 outputs
• UART, I2C and SPI hardware interfaces

We suggest using AVR-gcc (like WinAVR) with the LUFA library or ‘Teensyduino’ Be sure to check out the multiple resources available at PJRC!

In stock and shipping now!

Adafruit, Arduino and others – Partners in Atmel University program!.

Welcome to the Atmel® University Program. Our mission is to support the academic community and to advance education through technology platforms, engineering resources and classroom solutions. You are invited to become a part of an educational community with over 1,000 members worldwide. Here, you can collaborate and learn from each other by sharing curricula training materials and student projects.

• Apply for donations
• Request student sponsorships
• Access curriculum material and labs (educators)
• Access training material
• Enjoy discounts and specials on recommended textbooks
• Get 50% discount on boards and kits, plus discounts and specials from partners
• Get free passes for special Atmel training events
• Get early access to product updates and news on Atmel events and training opportunities

Students can benefit from the training videos, articles and documents that are provided on the Atmel University page and our YouTube Channel. Students can also request sponsorship for competitions and other creative ideas; these requests will be reviewed on a case-by-case basis. To receive all the student benefits of our program, we encourage student registration.

We are very excited to be part of this program and partners with Atmel, Arduino and all the other great companies! Read more!

Back in March, I released the design for the BB-313, a breadboarding platform for the ATTiny2313/4313. After some great feedback and many requests, I’m happy to announce I’ve started selling the PCBs.

These are nice, lead-free boards with a good-quality silkscreen, and they’re available in any color you want, as long as it’s green. Boards are $5/each + $2.50 shipping within the US. Check out the PCBs section of the project page to place an order or for more information.

Thanks to everyone for their amazing feedback and support on this project — the enthusiastic response means that I can continue to develop and share new open hardware designs.

Note: these PCBs are being sold directly by me (johngineer), and not by Adafruit.

Another week, another pinout reference.:)

A follow-up to my Arduino Leonardo pinref, I’ve created a reference sheet for the Adafruit ATMega32u4 Breakout board. Useful for seeing at a glance which pins can do hardware PWM, have an ADC, or can trigger low-level interrupts.Very handy for breadboarding.

The reference is available and as an image or a PDF: the full-size image is here; you can download the PDF here, or from the product page (under ‘downloads’). The PDF prints onto a standard 8.5×11 sheet, with the board at 2x the actual size.

Happy hacking!

Atmel’s new videos… “Manipulating the RSTDISBL fuse”. That’s Dean of LUFA fame!

How to program the (RESET) PC6 line as a general I/O port using High Voltage Parallel Programming Mode (HVPP) on an ATmega8.

Here’s the old one.

Over at TVHeadedRobots.com, there is a nice tutorial on taking our AVR ISP Programmer Shield Kit, and tweaking it to accept any sized AVR chip. They go over some common issues that you may run into and how to fix them, like stopping your Arduino from auto-resetting.

Read the full tutorial here, and pick up an Adafruit AVR ISP Programmer Shield Kit here.

Getting an AVR to blink might seem like an incredibly difficult task compared to the usual Arduino blink, but it really isn’t! In this post we will be uploading a basic blink example to an ATtiny2313. This is perfect for projects where using an Arduino would be over the top. So let’s get started!

from ApexLogic:

The fiber optic chandelier was inspired by one that was for sale on Ebay.com. The asking price for this assembly was over $1000.00. On top of the extensive price the features were also very limited. After some time brainstorming a design was set in place to achieve the following goals.

• Wireless control
• RGB color selection
• Custom Look

Lots more photos, build details and great tips for beginners on working with fiber on the website. All the code and schematics are on the code page. Nicely done!

Brain-Computer Interface Using Single-Channel Electroencephalography.

We developed an EEG brainwave-controlled Pong game using an AVR microcontroller. It uses alpha wave modulation based on the spectral power to control the paddle position. If you relax, the paddle moves up, and if you concentrate, the paddle moves down.

Hi there, A followup to this mail from a couple months ago. I started with your USBtinyISP design and ended up with this. It’s not recognizably based on your circuit anymore, and it has a few more big features (dual power supply, JTAG programming, USB-TTL serial, rescue clock). But a little bit of the USBtiny’s soul is still
there! You can follow along with the development on my blog: http://www.sowbug.com/

AvrPhone is a simple mobile phone with a touchscreen. His brain is AVR microcontroller ATmega128 (128 kB flash, 4 kB SRAM) and user interface provides 2.4 “LCD display with touch foil and controller ILI9325B , equipped with 16-bit bus. The communication module provides GSM SIM100S čísnkého manufacturer Simcoe. The whole system is powered by a 3.7 V/1000 mAh Li-Pol cells.

Electronics-Lab.com Blog » Testing CMA-77-100 antenna with SYM-RFT-77 DCF77 receiver module.

We are in the prototyping phase of building a Nixie clock using 1N-14 Nixie tubes. The clock is designed around a PIC16F886 MCU, 74141N BCD decoder/driver and CNY74 optocouplers using common circuit topology. High DC voltage (+ 180VDC ) is generated using MAX1771 step-up switching regulator, which is quite efficient (if you use appropriate components).

Avrian Jump via Hack-a-Day…

A very simple ladder language for programming ATMega168s from a web browser. This started out as a desire to be able to program an Arduino from an iOS device. Since it doesn’t seem like compiler tools of any sort would get into the app store, I figured something would need to be done in HTML5. And if a PC emulatorcould be written in javascript, so could something like this. However, recreating the Arduino IDE in HTML seemed like too much work, at least for a first try. So I reduced the project into something much simpler, while still putting real machine code into the AVR’s flash. A simple ladder language that compiled into AVR assembly, which would be assembled into machine code, seemed like like a resonable reduction. With that I could take advantage of the Audioino bootloader, to load right from the web page.

Four Walled Cubicle – AVR Articles. Dean writes -

Over the years I’ve written a few fairly lengthy tutorials relating to AVRs. Originally, I posted these over on the AVRFreak’s Tutorials forums, but after many requests for PDF versions and after becomming frustrated at the lack of typesetting expressiveness given in the forum software, I converted over the text into LaTeX.

Now the tutorials are available in PDF form, and can be freely redistributed under an MIT license. I’ve even put up a public mirror of the tutorial LaTeX source SVN repository, so that others can fork off and examine past revisions of the files as I update them in the future.

I created this reference sheet for my BB313 board outlining all the alternate pin functions and descriptions. While I’ve pretty much got the pins memorized at this point (from constantly cross-checking with the ’313 datasheet), I wish I’d thought of this earlier. The sheet is a single-page 8.5×11 PDF, so you can just print it out and keep it for reference at the workbench (or desktop). You can get the PDF, as well as all the project source files, at the GitHub project page.

Teensy Based IR Blaster via the Adafruit customer support forums… Bbum writes -

When I started this, as can be seen in the image below, the case was two parts that fit together in a semi-complex manner (Actually, the very first version just had a little plastic square that covered the AVR, but nothing else). It was hard to print with any quality and, frankly, the front looked awful. So I simplified it such that the IR LED could stick out a small hole, as seen in the middle. But then it dawned on my that the translucent plastics might just be transparent enough to IR that no hole was needed at all. And sure enough, it just worked! Thus, the design is now even simpler (assuming you have translucent filament).

Atmel University (With Arduino classes) via Twitter and Dangerous Prototypes.

Welcome to the Atmel® University Program. Our mission is to support the academic community and to advance education through technology platforms, engineering resources and classroom solutions.

You are invited to become a part of an educational community with over 1,000 members worldwide. Here, you can collaborate and learn from each other by sharing curricula training materials and student projects.

• Apply for donations
• Request student sponsorships
• Access curriculum material and labs (educators)
• Access training material
• Enjoy discounts and specials on recommended textbooks
• Get 50% discount on boards and kits, plus discounts and specials from partners
• Get free passes for special Atmel training events
• Get early access to product updates and news on Atmel events and training opportunities

cross posted from my blog.

For an embedded project I’m working on, I had to implement an algorithm to convert from HSB (hue/saturation/brightness) to 8-bit RGB color values for PWM’ing LEDs. This is what I came up with. It creates a ‘constant brightness’ RGB value: at full saturation (no ‘whitewash’), only two of the 3 RGB colors are on at a time, and their ‘on’ times are mathematically complimentary (though not phase-complimentary) with respect to the max 255 value.

Increasing saturation will increase the overall brightness of the LEDs, but that is to be expected — for a given maximum magnitude, there is more overall energy in white light than there is in light of a particular color. The saturation calculation works by adding a constant ‘floor’ value to all channels. Individual color values are then placed between this floor and the 255 maximum. A saturation value of 0 results in all channels at 100% duty cycle.

The ‘brightness’ is the last calculation performed. It takes a saturation modified hue value, and simply proportions it to the maximum value. So, a brightness of 197 will output light which is ~197/255 of the maximum output value. Naturally, there are losses inherent to integer arithmetic, but it’s close enough for most uses. Further, the linear nature of the brightness control means it is not ‘gamma corrected’ — that would require logarithmic brightness control which, for what I’m doing, is completely unnecessary.

This algorithm uses no sine tables or floating point math, so it’s pretty fast, though it could probably be optimized to use shifts and adds instead of mults and divides. It’s also relatively small. The code itself is in C, so it can be used on most platforms.

Click ‘more’ for the code snippet and just copy/paste into a text editor –

/******************************************************************************
 * accepts hue, saturation and brightness values and outputs three 8-bit color
 * values in an array (color[])
 *
 * saturation (sat) and brightness (bright) are 8-bit values.
 *
 * hue (index) is a value between 0 and 767. hue values out of range are
 * rendered as 0.
 *
 *****************************************************************************/
void hsb2rgb(uint16_t index, uint8_t sat, uint8_t bright, uint8_t color[3])
{
	uint16_t r_temp, g_temp, b_temp;
	uint8_t index_mod;
	uint8_t inverse_sat = (sat ^ 255);

	index = index % 768;
	index_mod = index % 256;

	if (index < 256)
	{
		r_temp = index_mod ^ 255;
		g_temp = index_mod;
		b_temp = 0;
	}

	else if (index < 512)
	{
		r_temp = 0;
		g_temp = index_mod ^ 255;
		b_temp = index_mod;
	}

	else if ( index < 768)
	{
		r_temp = index_mod;
		g_temp = 0;
		b_temp = index_mod ^ 255;
	}

	else
	{
		r_temp = 0;
		g_temp = 0;
		b_temp = 0;
	}

	r_temp = ((r_temp * sat) / 255) + inverse_sat;
	g_temp = ((g_temp * sat) / 255) + inverse_sat;
	b_temp = ((b_temp * sat) / 255) + inverse_sat;

	r_temp = (r_temp * bright) / 255;
	g_temp = (g_temp * bright) / 255;
	b_temp = (b_temp * bright) / 255;

	color[RED] 	= (uint8_t)r_temp;
	color[GREEN]	= (uint8_t)g_temp;
	color[BLUE]	= (uint8_t)b_temp;
}

Lianna has optimized the code (below, in the comments), but some of her parentheses are showing up as smilies. I don’t know how to fix that so I’ll just add it to the post as preformatted text. Thanks Lianna! Great work!

Lianna’s version 1:

void hsb2rgbAN1(uint16_t index, uint8_t sat, uint8_t bright, uint8_t color[3]) {
    uint8_t temp[5], n = (index >> 8) % 3;
    temp[0] = temp[3] = (uint8_t)((                                        (sat ^ 255)  * bright) / 255);
    temp[1] = temp[4] = (uint8_t)((((( (index & 255)        * sat) / 255) + (sat ^ 255)) * bright) / 255);
    temp[2] =          (uint8_t)(((((((index & 255) ^ 255) * sat) / 255) + (sat ^ 255)) * bright) / 255);
    color[RED]  = temp[n + 2];
    color[GREEN] = temp[n + 1];
    color[BLUE]  = temp[n    ];
}

version 2:

void hsb2rgbAN2(uint16_t index, uint8_t sat, uint8_t bright, uint8_t color[3]) {
    uint8_t temp[5], n = (index >> 8) % 3;
// %3 not needed if input is constrained, but may be useful for color cycling and/or if modulo constant is fast
    uint8_t x = ((((index & 255) * sat) >> 8) * bright) >> 8;
// shifts may be added for added speed and precision at the end if fast 32 bit calculation is available
    uint8_t s = ((256 - sat) * bright) >> 8;
    temp[0] = temp[3] =              s;
    temp[1] = temp[4] =          x + s;
    temp[2] =          bright - x    ;
    color[RED]  = temp[n + 2];
    color[GREEN] = temp[n + 1];
    color[BLUE]  = temp[n    ];
}

A little over a year ago, I started playing around with the newly available AVR ATTiny4313. It’s a neat little chip, and you can have a lot of fun with it. However, I soon got tired of wiring up programming headers, power supplies and all the other stuff you need to get up and running. I also grew wary of all this support circuitry taking up significant breadboard real estate.

To eliminate all that hassle, I created the BB313. It’s got all the stuff you need (programming header, regulated 5V power, etc.) wrapped up in a nice little package, and it plugs in on the edge of the breadboard so you have lots of space for other stuff. I also added an 6-pin connector for an FTDI cable or adapter.

I originally designed it for myself, but I figured other people might like it too, so I’m releasing it open-source CC-BY-SA 3.0) so you can make your own.

All the details and source files are at the project page. If you find it useful, please let me know!

this post is a duplicate of a post at my blog.

NEW PRODUCT – Teensy++ (AT90USB1286 USB dev board) + header! The Teensy++ is a complete USB-based microcontoller development system, in a very small footprint! All programming is done via the USB port. No special programmer is needed, only a standard “Mini-B” USB cable and a PC or Macintosh with a USB port. Its the big sister version of the popular Teensy board we carry, this board has tons of FLASH, RAM, pins and more. This is the latest version, 2.0.

Key Features:

• USB can be any type of device
• AVR processor, 16 MHz
• Single pushbutton programming
• Easy to use Teensy Loader application
• Free software development tools
• Works with Mac OS X, Linux & Windows
• Tiny size, perfect for many projects
• Comes with headers pins that you can solder on to plug it into any solderless breadboard

Comes with assembled Teensy++ board (AT90USB1286 with bootloader preinstalled) and header to allow easy breadboarding. We suggest using AVR-gcc (like WinAVR) with the LUFA library or ‘Teensyduino’ Be sure to check out the multiple resources available at PJRC!

Dimensions: 2″ x 0.7″

• FLASH: 130048 bytes available
• RAM: 8192 bytes
• EEPROM: 4096 bytes
• IO: 46 pins
• ADC: 8 analog inputs (multiplexed to one ADC)
• PWM: 9 outputs
• UART, I2C and SPI hardware interfaces

We suggest using AVR-gcc (like WinAVR) with the LUFA library or ‘Teensyduino’ Be sure to check out the multiple resources available at PJRC!

In stock and shipping now!

AltSoftSerial Library, for an extra serial port. Paul Stoffregen, designer of the Teensy board we stock has an intriguing new Arduino Software Serial library. This one uses the 16 bit timer to do data capture and transmission…

It’s ideal when you need simultaneous data. If you try the example that comes with SoftwareSerial in Arduino 1.0, and type “Goodnight” in the Arduino Serial Monitor, you’ll see what actually comes out of pin 3 at 4800 baud is “Goot”. The characters “dnigh” are lost. The reason is because while SoftwareSerial is sending the letter “G” at 4800, the letters “oodnigh” arrive at 57600 baud. Only “oo” are held in the UART registers. The rest are lost because interrupts were disabled for too long.

Often people misunderstand these problems and falsely attribute them to NewSoftSerial’s inability to keep up with the rapid pace of data. In this example, the failure is actually on the hardware serial reception. NewSoftSerial is easily able to work at 4800 baud, but in doing so it interferes with other things.

Hobbyist Electronics – Akafugu.jp – New version of the Microcontroller Reference Sheet with Arduino-tiny pinouts. They also added the ATTinyX4 series of processors.

BACK IN STOCK – Atmega32u4 Breakout Board. Toss out those FTDI cables and go USB-native with the ATmega32u4. After many months of back-orders, we finally received a shipment of these little guys and are excited to offer our breakout board. The little dev board keeps it simple, with just the bare essentials:

• Atmega32u4 – AVR core with USB capability. 32K flash, 2.5K RAM running at 16MHz
• Standard AVR 6-pin ISP connector for direct programming (when you need the extra space)
• Big Bootload/Reset button
• 500mA fuse on the USB power line
• Power LED and ‘user’ LED (also indicates when the bootloader is active)
• Fits nicely in any breadboard
• 4 mounting holes

This breakout board is best for those who have familiarity with some microcontrollers and are comfortable with writing code in C. This board doesn’t come with any ‘learn to program’ tutorials! If this is your first time with a microcontroller, we suggest going with an Arduino which is easier. Then when you want to upgrade, check this out.

Plug it in, connect a mini-B USB cable and you can start writing code immediately. With the built-in bootloader you don’t even need an AVR programmer. We suggest checking out the LUFA library to get started with the USB core as nearly every kind of device has an example already.

In stock and shipping now!

Driving 595 Shift Registers. Mike writes in -

Thanks for the ATmega32U4 Breakout Board and TPIC6B595 chip. They are super! I am using them to learn basics.  I always write a blog entry about what I learn. This way I am forced to learn the details and remember things better. Currently learning about shift registers and SPI.

Self-Balancing Electric Unicycle. Stephan writes -

I recently built a partially self-balancing electric unicycle called “Bullet,” featuring:

• A custom MIG-welded steel chassis
• A 450 Watt electric motor
• Two 7 Ah 12 Volt batteries
• A 5DOF intertial measurement unit
• The OSMC H-bridge
• An ATmega328P microcontroller

I say “partially” self-balancing because it only balances along one axis (forward/backward), and the rider still needs to balance left and right (it’s analagous to riding a bicycle “no hands”). It operates much like a Segway — you lean forward to accelerate, and lean back to brake. The top speed is about 15 mph, and it easily goes 5 miles on a single charge. This is my primary mode of transportation on the MIT campus.

Festivize your bench this holiday season with an oscilloscope Christmas tree:

When I was a little kid, my dad worked at Bell Labs. Every year around Christmas, we’d go visit him at work. One memory which has always stuck with me from my holiday visits was seeing a Christmas tree on an oscilloscope. I was pretty amazed by it. Engineers are a funny bunch — they tend to celebrate holidays in the most uniquely nerdy and wonderful ways, just like kids. When I recently acquired a new ‘scope and wanted to familiarize myself with it, I knew exactly what my test circuit was going to be.

In honor of the nameless BTL engineer whose scope scribbling captivated me as a child, here we are. Maybe the same thing will happen for some other kid. There are a lot of holiday parties coming up. You could put this on one of your scopes at work or at your hackerspace, and some other kid will see it, and it’ll fire their imagination too. It looks pretty neat at any rate, and it’s downright fascinating after a few fortified egg nogs.

Schematics, code and further ramblings over on my blog.

Dean Camera joins ATMEL as AVR Applications Engineer…

At the completion of my internship at Atmel Norway in late 2010, I was offered a full time position working as an AVR Applications Engineer in the Atmel Norway facility. While the start date of this job was delayed to give me time to finish my University degrees, I have now completed all required materials and am only a few weeks away from the big move. In early 2012, I will be moving across to the other side of the world, to join the ranks of the Atmel AVR Applications group and live in Norway.

ATMEL is getting serious.

Interesting! Atmel is looking for “Mobile Device Drivers Architects ( Win7 or Android ) at Atmel Corporation” and “Sr Software Development Architect (mobile electronics)”

Designing and implementing device drivers for mobile space operating systems such as Android to interface to user interface co-processors.
Managing the technical relationship with operating systems companies to specify next generation feature sets.
Team leader for a distributed group responsible for designing, building, integrating, testing, validating and documenting device drivers.

Thanks Dan!

Adafruit AVR Sticker for Breadboard Arduino-compatibles – 10 pcs. These stickers are a must for anyone making a breadboarded Arduino-compatible. They fit right on top of a DIP ATmega328 (or ’168) chip, and clearly indicate every pin as it would be called in the Arduino IDE. Inspired by our video producer George Graves, we are thrilled to have these in stock!

No more looking up the datasheet or schematic! The stickers are made of a tough vinyl, usually used for bumper stickers, so they will not fade, scratch, or wrinkle. The stickers are die cut already into a rounded rectangle that fits on top of the AVR. 10 stickers made of vinyl. Each stickers is 7mm x 34mm.

Comes in a pack of ten, so you never need to feel like you’re about to run out. AVR chips are not included, but we do have Arduino-bootloader chips in the shop.

In stock and shipping now!

We will also have one with AVR pin names soon too, stay tuned

Camera-B-On TV-B-Gone via HaD… Christopher writes -

I have created a Camera-B-On TV-B-Gone. This fairly simple mod allows me to use my TV-B-Gone as a camera remote for my Nikon D90. In fact, this will work as a shutter remote for a lot of Nikon cameras.

If you have a USBTinyISP you can easily make a Camera-B-On by upgrading your TV-B-Gone.

RoboProgrammer – Automated AVR (or PIC etc) programmer.

RoboProgrammer is an automated way to program numerous microcontrollers using different firmwares, in a playlist-like manner! It was built using GRoboduino as the controller and an arduino duemilanove as AVR programmer.

Thanks Josh!

www.youtube.com/watch?v=314v1H_aN2o

8 bit device kindles eBook fire: An e-reader for the microtouch @ rossum’s posterous. He writes -

With all the fuss over Kindle Fire I thought it might be fun to see if the humble 8-Bit microtouch hardware would do a servicable job as an e-reader. With a bit of fiddling it turns out to be a quite capable if not entirely practical eBook.

There are hundreds of thousands of books available in the epub format. The format is essentially a collection html/css/jpeg files and xml metadata such as author/title/table of contents bundled into a zip file (If you want to look inside an epub file simply change ‘.epub’ extension to ‘.zip’ and double click). I thought it might be possible to build a reader for the microtouch that would directly read a standard epub but the code and memory requirements for things like jpeg/png/gif decoders, xml parsers and decompression overwhelmed the available 2.5k RAM/32k Flash. The alternative was to transcode into a format that retained all the structure of the epub in a form easily digestible by a small, 8-bit device.

Read more…

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.

On board you will find a whole bunch of goodies:

• Atmega32u4 – 32KB of flash, 2.5K of RAM with usb bootloader
• 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’
• Calibrate Touch-screen
• Doomed a 3D rendering maze
• Accelerate keep the ball in the center of the screen by tilting
• Paint fingerpainting but without the cleanup
• Flip a Reversi game
• Mines like Minesweeper but without the hassle of installing Windows
• 3D Icosohedron controllable by tilting the board
• Pacman a sprite animation demo
• Lattice 3D lattice demo

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.

The project is a collaboration between Rossum & Ladyada! For detailed documentation and files, please visit the product page

Blondihacks has developed a breadboard programming header for 8-Pin AVR microcontrollers called the Bread Head.

This little guy was easy to make, and has been a real time saver when iterating on a breadboard. The trick is upside-down protoboard, and longer-than-usual headers! Read on to see how it’s built.

This simple add-on looks to work great with the USBtinyISP AVR programmer kit!

Atmel’s CEO Discusses Q2 2011 Results via Twitter.

Revenues for the second quarter increased 4% sequentially and 22% as compared to the same quarter in 2010 to $478.6 million, at the high end of our guidance about 1%, 4% sequentially. Our quarterly revenue reached the highest level in over 10 years and is Atmel’s ninth consecutive quarter of sequential revenue growth. Excluding the Smart Card sold at the end of the third quarter in 2010, revenues increased 31% when compared to the second quarter of 2010.

We set another record for gross margin. Second quarter 2011 gross margin was 51.8%. The second quarter gross margin was an 80 basis point improvement from the 51% we reported last quarter and ahead of our guidance of 51%.

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

Perfect for Sous Vide cooking! ( For more information about Sous Vide: en.wikipedia.org/​wiki/​Sous-vide )

Source code is available at bitbucket. Nice work, Stian!

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.

Jeremy writes:

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.

Nice work, Jeremy!

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.

Hackers pierce network with jerry-rigged mouse…

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.

Read more!