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!

Linus (lft) writes:

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!

Nathan writes:

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.

Cool idea! Check out Nathan’s project page here, and get the source code here.

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

Here’s a video of version 1.0 (this one is v2.4 and uses a different chip but is pretty much the same functionally) You can see the apps in action!

We are also carrying a lot of accessories for the board, you can see them here.

In stock and shipping now.

CalebEng writes in…

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.

Matt writes -

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.

Bruce writes in…

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.

rbw writes -

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.

Via Tayken’s Blog

Using an AVR as an RFID tag, Beth writes…

Last time, I posted an ultra-simple “from scratch” RFID reader, which uses no application-specific components: just a Propeller microcontroller and a few passive components. This time, I tried the opposite: building an RFID tag using no application-specific parts.

Well, my solution is full of dirty tricks, but the results aren’t half bad. I used an Atmel AVR microcontroller (the ATtiny85) and a coil. That’s it. You can optionally add a couple of capacitors to improve performance with some types of coils, but with this method it’s possible to build a working RFID tag just by soldering a small inductor to an AVR chip

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.

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!

Get’em now in the Adafruit store!

OK, so say you have this crazy cool idea where you need to control a ton of LEDs (I know, I know… LEDs). You looked at the multiplexer article, and that was great, but this idea is so cool, you need individual control of each LED, and turning them on one at a time just won’t do. Well again, we are here to help, and now it’s time to introduce you to the Shift Register. Not just any shift register, the super cheap, incredibly awesome 74HC595 8-bit Shift Register!

With a video, diagrams, even AVR and Arduino code samples!

Paul, maker of the Teensy writes -

Counterfeit Teensy boards have appeared on the market. Counterfeit boards are not compatible with Teensy Loader and Teensyduino, and may not work with many projects. Counterfeits may be sold as “Teensy 2.0″ but have hardware similar to version 1.0 (see below). PJRC does not provide technical support for counterfeit products! Please be careful to buy only genuine Teensy USB development boards.

Adafruit carries the real deal directly from Paul of course. We always support the maker and designer and our customers like that as well. There are likely clones of Paul’s work because there was/is a lot of demand for these because they can be used to jail break Playstation 3 units.

We thought we’d use this opportunity to discuss a related topic – open source hardware vs non-open source hardware. The Teensy is not open source hardware, while we wish it was, we respect Paul’s wishes to distribute any way he wants and retain any rights he wants. Some customers have complained about the Teensy not being open source hardware – and others have said that open source hardware is a “bad idea” because some can clone / counterfeit it so easy. So here we are, the Teensy is cloned / counterfeited and it’s not open source hardware. It doesn’t matter if something is OSHW or not – if someone wants to clone hardware they will.

We think that anything interesting may get cloned, if something is open source hardware it can be cloned too – but along the way you get community, contributions and more. Would the Teensy be cloned if it was OSHW, of course it could, but there would be an entire community who spent time and effort with a sense of ownership could help get these stores to buy directly or at least work out a licensing agreement with the makers. Maybe Paul has a trademark on the name and can work with the USA based sellers of the clones to get them to reconsider carrying the clones or changing the name. Any way, all guesses – please consider getting a real Teensy from us or Paul and supporting the maker.

We’re not sure what will happen with this example, but wanted to share it – for the people who say they will not do open source hardware because “it might” get cloned, here’s an example of hardware that was cloned that clearly was not OSHW.

AVR Basics: Reading (and writing) flash contents @ Evil Mad Scientist Laboratories via .

Reading out the flash memory is straightforward with an AVR ISP programmer, such as the USBtinyISP, using avrdude from the command line. You’ll need to have a copy of the AVR toolchain– or at least avrdude –installed on your computer. There are easy installers available for Mac (Crosspack) and Windows (MHV AVR Tools) that include this software, along with the other open source tools for AVR development. Linux packages for AVR development are also available.

This belt we made debuted during “Ask an Engineer” – it uses 1 meter of our Digital RGB LED waterproof flexi-strip, an Atmega32u4 Breakout Board+, Lithium Ion Polymer Battery and a USB LiIon/LiPoly charger.

AVR Programming 02: The Hardware @ Hack a Day. Be sure to check out the first in this series as well…

We put these back in stock today, the were taken out during some crazy PS3 hack that have have now blown over.

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.

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!

Get’em now in the Adafruit store!

This project tutorial will show you how you can convert a console game pad into a USB keyboard mouse for playing games on your PC. The USB game pad can be used with nearly any software, such as a MAME emulator, game, simulation software, or for custom user interfaces. We’ll start by turning the buttons of the game pad into keyboard buttons, so that pressing ‘up’ is converted into the ‘U’ key, for example. The firmware is easily adaptable, so you can adjust it for whatever software it will be used with. Then we’ll make the project more interesting by adding an accelerometer. This will allow the game pad to be used as a mouse by tilting it! This tutorial including the original code and Portal video is by Devlin Thyne! Rock!

You’ll need the following in order to build the project:

• Game pad – We’ll be using an SNES controller
• Teensy – This is a very small microcontroller board that can act as a keyboard/mouse
• Triple-axis accellerometer – We’ll be using the nice ADXL335 on a breakout board. You can skip this if you’re not planning to add in the mouse capability
• USB cable with mini-b connector – to attach to the Teensy for plugging into a computer!
• Ribbon cable – for all the soldering connections. Rainbow cable is the easiest to work with as its color coded

If you want to build the entire project, we have a project pack in the shop with all the parts listed above!

You’ll also need some basic hand tools such as screwdrivers, wire strippers, soldering iron, solder, diagonal cutters, vise or third hand tool, etc.

All the code is on GitHub, including some extra sketches we’ve written so be sure to look there!

Read the entire tutorial here!

Atmel just opened up a store online. Thanks Macman!

Here’s a tutorial page for the FTDI friend with some information on drivers and files, we also include a little hack on using an FTDI chip as a slow but functional AVR programmer. If you’re in a pinch and need to program an Arduino bootloader but don’t want to replace the drivers and avrdude, this will work with just a single wire soldered on… FTDI Friend – Breakout Board+ (tutorial)

• Installing windows drivers (mac/linux don’t need to install drivers!)
• Identifying the COM/serial port (mac/windows/linux)
• Whats the difference between an FTDI cable/adapter and an AVR programmer?
• How to use the FTDI friend as a (slow) AVR programmer
• How to burn Arduino bootloaders using the previous tutorial

Connecting a microcontroller to a computer or laptop is a common problem: For decades, all computers had serial ports and parallel/printer ports. These were great for engineers because they were easy to connect to – data sent from the computer showed up exactly the way it was sent. Nowadays, few computers have parallel or serial ports, they have been replaced with USB. USB is better for users because theres only one connector, and information can be sent really fast with no errors.

But the trade-off is that USB is more complex than serial or parallel since data is wrapped in complicated, super-fast packets. So what if you still want that serial port? Well, you can use a usb-serial converter. These have little chips in them that are very specialized – they show up in your computer as a serial port but they do it through USB. The good news is that these are very common and cheap, but the bad news is that they are not very good for microcontroller hackers.

Why? For one thing, these big 9-pin cables had to reach many meters so what the designers did is make the voltage on them rather high, about 20V from negative to positive. Microcontrollers tend to want no more than 3 or 5V! Plugging this into your microcontroller will quickly damage it permanently! If you want to use one of these cables with your micro, you can build a converter from the 20V down to 5V, often called a MAX232 converter. Some cables are hackable to bring the voltage down so if you’re excited to tear apart an adapter and solder some wires that can be a solution. For most makers, we really suggest you use is an FTDI cable or adapter.

FTDI chips simply take the USB signals and output 3 or 5V cleanly, so you don’t have a risk of zapping your electronics. Another nice thing about these cables and adapter is that you can use the 5V from your computer to power a project, up to half an amp. Basically like the USB/serial adapters they show up as serial ports to your computer, but these have the right voltage levels.

We have two options for FTDIness, cables and adapters. The cables are all in one piece with plugs on either end. The FTDI chip is inside the head of the cable. The adapters are small circuit boards, you can use any miniUSB cable, and the plug in the end matches the pinout of the cable. So why would you want the circuit board? For one, its a little less expensive. Another thing is that it has visible LED that blink when serial data is sent or received, which can be handy for debugging. Another fun thing you can do with the FTDI friend is change the voltage levels for power and data from 5 to 3v or change the 6th pin from RTS to DTR which may be useful for some hacker projects.

OK one question we get a lot is whats the difference between something like the USBtinyISP programmer and an FTDI adapter? Both plug into a USB port, that is true, and both can be used to program AVR. but they are different things. The USBtinyISP and other USB AVR programmers are specially made to program raw AVR microcontrollers, just as they show up from the factory. The USBtinyISP isnt meant for sending debugging messages or other data. On the other hand, if you have a chip with a bootloader on it already, like an Arduino, you can use the FTDI friend to upload new firmware and transmit serial data for debugging or logging.

However, you can’t really use the FTDI friend to program a raw chip without a lot of effort and its pretty slow. So, for programming new AVRs, use a USBtinyISP. To bootload onto preprogrammed AVRs and pass data, use a FTDI friend.

Remember, FTDI Friend is your friend, not your FTDI enemy.

from BitArtist.org:

Previously, we discussed about bluetooth module used with Android Nexus One, so today, we would like to present our latest project here “Android controlled wireless lamp”, We want to do somethings meaningful with the bluetooth module with Android, so we modify a small lamp and adding the bluetooth connectivity to it.

Sometimes, we may put the phone in bedroom, and we will not know someone is calling. With the bluetooth connectivity, it can communicate with your Android phone at least 10 meters or above. You can put the lamp near your TV or anywhere you stay. Also, you can use Android as a remote control to turn on/off the lamp (or any devices).

Nice! USBTinyISP drivers for 64-bit Windows 7 / Vista x64, Jeff writes -

For some reason, the 32-bit versions of these operating systems don’t prevent the unsigned drivers from being installed, although they do complain.

There are a few workarounds that involve hacking Windows or disabling digital signature checking, but thanks to a tip by user wayneft on the Adafruit support forums, I was able to make the process much more straightforward. The USBTiny drivers are based on libusb-win32.  Based on some notes I found on the libusb-win32 wiki, I discovered that the latest libusb drivers contain a proper digital signature…

I used the Windows device manager to upgrade the broken drivers on my Windows 7 64-bit machine.  There is still a warning that “Windows can’t verify the publisher of this driver software” but there are no more errors about digital signatures and the new drivers appear to install and work correctly.

AVR programming trick: Sharing target boards @ Evil Mad Scientist Laboratories…

This week, Brad wrote in with an interesting question: Can you program the ATtiny25 on one of our ‘tiny2313 target boards? And the answer is yes: you can, with just a trivial modification.

Okay, back up– a little context here. The ATtiny25 and the ATtiny2313 are examples of AVR microcontrollers, the little brains that power many of our projects.

To program these chips, we use a usbtinyisp programmer, hooked up to a minimalist target board

Some good stuff for the AVR freaks up in here, Alastair writes in…

Here’s a replacement for WinAVR with up-to-date tools (since WinAVR has been abandoned, and nothing has yet been released from Atmel) & an efficiency oriented runtime library for AVR microcontrollers, for those ready to graduate from the Arduino environment.

Developing Software for the Atmel AVR with AVR-Eclipse, AVR-GCC & AVRDude from Interactive Matter -

Developing software – or better firmware – for the Atmel AVR can be quite easy or quite complicated. A lot of people like to just use vi, some source files and a make file. Here at Interactive Matter we are a tad lazy and want a fully fledged IDE, with code completion, one click building, no make files and buttons to flash the AVR. The easiest was is to achieve this with Open Source Software, using avr-gcc, avrdude and avr-eclipse. This guide explains how to install and use it.

Full tutorial here.

TL;DR – In order to get raw parsed data out of a magstripe reader, we first experimented with a MAGTEK Centurion Keyboard Encoder (PN-21073062). We found that although we could get all 3 tracks of data, it was not possible to have it parsed out. We then purchased a raw magstripe decoder head with track 1 reading, the Omron V3A-6. By writing some parity checking code, we were able to read the raw data off of the magstripe, and parse it into output that would be ‘typed out’ as an emulated keyboard using a USB-enabled Teensy. An Arduino can also be used, and the data would be output as Serial which may also be useful.

Source code and some handy datasheets are on GitHub. Click Download Source to get the latest version.

We also suggest checking out StripeSnoop which despite being a couple years old, was extremely useful!

This project can only be used for card reading, not writing. There is no way to convert a card reader into a card writer.

So there I was, 5 days before HOPE (Hackers on Planet Earth) conference – getting ready for our booth that would be running all weekend. We had a similar booth at the previous HOPE, and it was pretty successful, one of the only things that hung us up was that we couldn’t easily accept credit cards and the ATM had run out of money. We could take credit cards but it took a long time and was typo-ridden because everything had to be entered into a website. See, instead of a boxy terminal, we were using a Virtual Terminal – a website that allows you to enter in all the important data (card number, expiration, name, amount, etc).

Click here to read more!

An ATTiny2313 powers this night light, driving multicolor LEDs diffused by ping-pong balls. nuumio writes:

Geir’s RGB night light was such an inspiration I just had to make my own.  Instead of Picaxes I decided to use ATTiny 2313. At first I tried to program it with C but I ran to some “differences of opinions” with gcc when I tried to assign dedicated registers to variables holding duty cycle values (for speed optimizations). After some struggling  I gave up and coded the whole thing in AVR assembly. I was quite surprised how easy it was after all. It took me about one weekend and I got first versions running nicely.

Great job, nuumio!

Homemade (AVR) speedometer via HaD. Howie writes –

My speedo cable snapped. Boo. The speedo was never very accurate anyway, so rather than replace the cable I figured it’d be fun to try making a digital speedo – plus it’s an opportunity to try using surface mount components rather than the bigger through-hole ones I’ve used so far. A bit of an ambitious design this time round – separate display and control boards, bigger and more complicated than anything I’ve done to date

Use this tool to sign the drivers with a test key and force windows to always boot in test mode. Works for me.

You can also try this – “Disable Driver Signing in Windows 7 Using Group Policy Editor“… we’ll try some/all of these out soon, for now – report back if you have anything to add!

V-USB is a software-only implementation of a low-speed USB device for Atmel’s AVR® microcontrollers, making it possible to build USB hardware with almost any AVR® microcontroller, not requiring any additional chip.

Thanks Travis!

Brian from Ohio writes in…

My goodness. Thank you *so* much for making the USBTiny ISP kit!… Thank you for sharing the fruits of your talents and work with those of us at home trying to learn how these things work. Without people like you and Windell & Lenore over at EMSL, I would never have started down this path. I’m having a great time, and my 9yo son is as well. He’s thoroughly intrigued by electronics and programming, and the tools you offer are an enormous help for us!

simavr is a new AVR simulator for linux, or any platform that uses avr-gcc. It uses avr-gcc own register definition to simplify creating new targets for supported AVR devices. The core was made to be small and compact, and hackable so allow quick prototyping of an AVR project. The AVR core works more or less perfectly now. The simulator loads ELF files directly, and there is even a way to specify simulation parameters directly in the emulated code using an .elf section.