Here’s more of the great 3D printed electronics enclosure tutorial series that I shared two weeks ago, from Inhale 3D:
In this Part 3, I’m extending the CAD-focused theme and up the ante substantially by showing you how to design a clam-shell style enclosure with a removable faceplate and front panel that has connectors protruding through the face plate. As always, the design has to be printable so there’s a proof-point by 3D printing the resulting design and, as previously offered, the design files are all available on Thingiverse so you can download and print them directly or play with the designs and modify them at-will if you have ViaCAD. The 3D print will be handled by my trusty LulzBot AO-100.
As before, the objective isn’t that this enclosure is specific to a real-world board, but the main objective is to show you what the process is to create an enclosure for an arbitrary PCB with connectors. That way, you can adapt these techniques your specific board and hopefully, the tutorial will be much more useful to you. There are many other details involved in making a real-world enclosure that we’ll get to in future tutorials, but just trying to make the first major leap from a simple clam-shell to an enclosure that has real functionality.
Every Thursday is #3dthursday here at Adafruit! The DIY 3D printing community has passion and dedication for making solid objects from digital models. Recently, we have noticed electronics projects integrated with 3D printed enclosures, brackets, and sculptures, so each Thursday we celebrate and highlight these bold pioneers!
Have you considered building a 3D project around an Arduino or other microcontroller? How about printing a bracket to mount your Raspberry Pi to the back of your HD monitor? And don’t forget the countless LED projects that are possible when you are modeling your projects in 3D!
The Adafruit Learning System has dozens of great tools to get you well on your way to creating incredible works of engineering, interactive art, and design with your 3D printer! If you’ve made a cool project that combines 3D printing and electronics, be sure to let us know, and we’ll feature it here!
Thanks for your great support. My son’s Ice Tube Clock works really well. He and I are so psyched!!! Hopefully he’ll get up on time tomorrow! (of course he will, we tested the alarm )
There have always been dozens of ARM options out there for development boards, but — for a variety of reasons — it’s always been a niche interest in the mainstream DIY community. 2012, however, may go down as the the year that ARM and 32-bit finally makes lasting inroads into hobbyists electronics.
There have been a lot of high-profile development tools and established environments embracing ARM in a more official capacity this year than any point in the past, and it’s probably never been easier or cheaper to benefit from the amazing processing power per dollar ratio that modern, low-end ARM Cortex M processors offer.
Interested in taking the 32-bit plunge? Hopefully this guide will give you a better idea of what options you have! (more…)
In today’s world, video game consoles have become increasingly complex virtual worlds unto themselves. Shiny, high polygon count, immersive, but ultimately indirect. A video game controller is your gateway to the game’s world—but the gateway itself can be a constant reminder that you’re outside that world, looking in.
Likewise, the technology in these game consoles has become increasingly opaque. Decades ago, platforms like the Commodore 64 encouraged tinkerers and do-it-yourselfers of all kinds. You could buy commercial games, sure, but the manual that shipped with the C-64 also told you what you needed to know to make your own games, tools, or even robots. The manual included a full schematic, the components were in large through-hole packages, and most of them were commonly-available chips with published data sheets.
Fast forward three decades. Today’s video game consoles are as powerful and as complex as a personal computer, with elaborate security systems designed specifically to keep do-it-yourselfers out. They contain dozens of customized or special-purpose parts, and it takes some serious wizardry to do anything with them other than exactly what the manufacturer intended. These systems are discouragingly complicated. It’s so hard to see any common link between the circuits you can build at home, and the complex electrical engineering that goes into an Xbox 360 or Playstation 3.
We wanted to build something different. Our platform has no controller, no television. The system itself is the game world. To make this happen, we had to take our engineering back to basics too. This is a game platform built using parts that aren’t fundamentally different from the Arduino or Maple boards that tens of thousands of makers are using right now.
This is the story of how we built the hardware behind the new Sifteo Cubes, our second generation of a gaming platform that’s all about tactile sensation and real, physical objects.
Beginnings
I’m Micah Elizabeth Scott, one of the engineers from the very small team that built this platform. When I started working for Sifteo in July 2011, the first generation Sifteo Cubes were about to go on sale. It was the product that the Sifteo founders created in order to bring their idea out to the world. When people outside our office started kicking the tires, they discovered what we already knew—there was something magical there, but it needed work.
It was the usual: better graphics, less money. Oh, and making it portable. One shortcut that allowed the Sifteo team to take their idea to market so quickly was that all games actually ran on your desktop or laptop computer. Games were written in a high-level language like Python or C#. They communicated with each cube via a 2.4 GHz wireless adapter, and the cubes acted like computer peripherals.
At first we tried taking some baby steps toward un-tethering our beloved cubes. We knew this was a problem we needed to solve fast, and anything we could reuse would help us toward that end. We tried to create a portable device that could take the place of the PC and communicate with the same cubes. It ran embedded Linux, and it looked like the charging dock. We called it SuperDock, and we invested quite a lot of time and money into it. Circuit boards, industrial design. I put together a distro with OpenEmbedded and wrote a kernel module for our radio hardware.
But it was clear that incremental change wouldn’t be enough. Games were written to expect a large CPU. The wireless protocol and graphics stack weren’t designed efficiently. The cubes used too much power, requiring a bigger and more expensive battery. Everything was interconnected, and everything needed to scale down. This was an uncertain time for the company, since any course forward would mean taking risks and going back to the drawing board.
We held a brainstorming meeting. We wanted to reduce our cubes down to their fundamental parts and eliminate unnecessary complexity, but we didn’t know what was really required to create the kind of tactile play we were interested in. We were open to trying just about anything, as long as it was fun and it seemed possible to create within our budget. A lot of ideas came out of this session, and most of them were extremely different from the first generation cubes.
Building a Lighter Bridge
Why were these designs so different? Well, we did look at doing a “cost down” on the first-generation design. Every part of it was too expensive. In so many kinds of engineering, scale ripples out. If you build a bridge with a really heavy surface, the supports for that surface have to be heavier too, and so on.
The original set included a 72 MHz ARM processor in each cube. It is roughly equivalent to the chip that powers the LeafLabs Maple board. This sounds paltry compared to the gigahertz processor in your phone, right? We’re so used to being surrounded by devices with chips powerful enough to run Linux, Android, or iOS. These chips aren’t even that expensive on their own. A top-of-the-line mobile phone CPU costs maybe $20. A more modest 375MHz ARM might be only $7 in quantity. Surely in a consumer product that costs upwards of $100, we could afford to ship three or four of these chips, right?
Not even close, unfortunately. In the bridge analogy, that’s only the cost for the pavement. You need support structures: power conversion, batteries, battery chargers, memory, programming infrastructure. These are significant costs, especially batteries and RAM. Now you multiply everything by a markup factor to account for the cost of assembly, running the factory, supporting the retailers. Every dollar you spend on the CPU turns into at least three dollars of cost to the end user.
Even that modest 72 MHz ARM was too heavy. We couldn’t afford a one-size-fits-all design. We needed to build a lightweight bridge from the ground up, using parts that would get the job done without overburdening the rest of the structure.
Just Add Magic
After that brainstorming session, I compiled a spreadsheet with all of the possible CPUs we could use if we wanted to try and build an optimized version of our cubes. To hit our cost and power budget, we would have to aim very low. And yet, we were still trying to create a next generation product with better graphics and gameplay. This would require deep magic.
There was one sweet-spot on that spreadsheet that intrigued me. We had some experience at using Nordic Semiconductor’s nRF24L01 radio chips. These are really convenient little radios, and they find a home in everything from DIY robotics applications to remote sensing. If you’ve used the TI/ChipCon CC2500 chip, they’re very similar.
These radios are also really common in wireless mice, keyboards, and video game controllers. For highly integrated battery powered applications like these, Nordic also makes a related chip: the nRF24LE1. This chip includes an 8-bit 16 MHz microcontroller with 16 kB of program memory and 1¼ kB RAM. It’s very similar to the ATmega168 chip used by most Arduino boards.
Could we use this part? It would have immense advantages in terms of making the whole bridge lighter. This system-on-a-chip combination is very power efficient. Furthermore, it does save money to have fewer chips in the system. When you buy one chip that includes a radio and a CPU, you’re only paying for packaging once. These chips also have some amazing economy of scale. Many different wireless keyboards and video game controllers use this chip, so we could get a better deal on it. It was an enticing possibility, but I had no idea whether it could be done.
Compelling Vaporware
Anyone, myself included, would have a hard time believing it was possible to redesign our game console around a chip no more powerful than the original Arduino. We needed a realistic demo. I had a graphics scheme in mind, but it would have required ordering parts and designing a PCB before we could build a hardware prototype. And even once we built the hardware, the software had better be correct the first time because there were very few debugging options available.
This wasn’t a problem unique to our project. In fact, chip designers have it pretty bad. Their solution: extensive use of software simulation. Simulators for integrated circuits are typically orders of magnitude slower than real-time, but they let you instantly try out changes that would have cost weeks and hundreds of thousands of dollars to try in silicon. Perhaps even more compellingly, they allow you to debug your design at a level of detail that wouldn’t be practical or even possible in the real world. So, I took a page from their book. I found an open source simulator for the 8051 instruction set, and used that as a starting point for building a special-purpose simulation to test this hypothetical hardware design.
After maybe a week of intense optimization and head-scratching, I had a prototype. The first new Sifteo Cube was a software simulation, and its firmware was a looping graphics demo. The simulation usually ran slower than real-time, but it would use accurate CPU cycle counts to calculate how many frames per second the real hardware would have been running at. This told me the design might actually work.
Taking Inspiration
This was quite a challenge: creating fluid 2D graphics on a chip designed to run wireless mice and keyboards, a peer of the original Arduino. No separate graphics chip, no custom-designed silicon. Just software and some very simple hardware. To make this possible, I took inspiration from the 1990s.
Why is it difficult to do graphics on a slow microprocessor, anyway? Pixels are just data. Unfortunately, there are quite a lot of them. Even our modest 128×128 pixel displays contain 16,384 pixels. That’s 16 pixels for every byte of RAM available to us. If we want to draw 30 frames per second, that means drawing almost half a million pixels every second! At a clock speed of 16 MHz, that gives us only 32 clock cycles per pixel, or roughly 10 instructions. That needs to be enough time to handle our sensor input, decompress data that comes in over the radio, and compose our final video signal for the LCD. We don’t have nearly enough memory to store all the pixels, and have almost no time to compute them.
Most classic 2D video game consoles faced the same challenge. In a previous life, I spent a lot of time reverse engineering and programming classic game consoles. I spent the most time with Nintendo’s portable Game Boy systems, but I also admired the architecture of the NES, Super Nintendo, and Atari 2600. All of these consoles managed to create graphics and sound that seemed far beyond the capabilities of their modest CPU power. They had some help from custom-designed chips, but the real magic came from a completely different approach to drawing.
One might call it cheating, but really the only winning move was not to play. Systems like the NES, Game Boy, and Super Nintendo solved this problem by opting out of pixels altogether. By operating on a larger unit, an 8×8 pixel “tile”, they gained an amazing amount of leverage. For example, one screenful of graphics on the NES would be 61,440 pixels. This would have been far too big to store on the game cartridges of the day, much less in RAM. But that same screen is only 960 tiles, which easily fit in the 2 kB of video memory.
This kind of leverage was common in the early days of PC graphics too. In 8-bit color modes, each pixel was a single byte stand-in, replacing a larger 18-bit or 24-bit color that lived in a colormap. Text modes used bytes which stood for characters, but the image of each possible character lived in a separate font table. These 2D video game consoles had similar tables, mapping an 8-bit tile index to an image of that tile, then using a colormap to expand that image into the final pixels you see on your TV. It was really a form of data compression. Unlike more modern algorithms, however, this kind of compression was designed so that the game engine and even the artists work directly with compressed graphics. They needed all the leverage they could get.
Pixel Pipeline
This tile-based graphics strategy would end up serving our needs really well. I wrote a graphics engine guide for our SDK documentation which describes our particular approach in a lot more detail. But there was still one big missing piece before we could implement tile-based graphics on this tiny chip.
The leverage gained by using tiles instead of pixels would make our graphics data small enough to fit in memory, but we still needed some way of sending pixel data to our LCD hardware. All of the classic game consoles had custom-designed chips to do this job. These chips interfaced directly with multiple kinds of memory. The NES used ROM for tile lookup tables and RAM for tile indices. Its graphics chip would use the settings in RAM to route pixel data from the correct part of ROM, colorize it according to the active palettes, then send it in real-time to the television:
This custom “Picture Processor” (PPU) chip had a lot of nice features: hardware support for sprites, scrolling, palette swaps. The critical functionality, though, was that it kept the high-bandwidth pixel data (the thick line above) out of the CPU. Software could make changes to the tile numbers in RAM at a relatively slow pace while the PPU streamed video out to the television without skipping a beat. We needed to figure out how to do this without any custom silicon. Luckily, the past few decades of advances in electronics have changed the game enough to make this possible.
Firstly, we aren’t using a television any more. Analog TV represents video as a waveform with very rigid timing. The NES PPU chip had to produce each pixel at exactly the right time, and it had no ability to pause the output to wait for other parts of the system to catch up. This alone makes it very challenging to generate analog television signals without some amount of hardware support. Projects like the Uzebox use very carefully timed software loops to generate analog video without any hardware support at all, but that comes at a cost. The Uzebox spends quite a lot of its CPU time just copying pixels.
Instead of a television, we use a small LCD module with a built-in controller chip, similar to many of the modules you see in the Adafruit shop. These chips are very common and inexpensive, and they contain enough RAM to buffer a single full frame of video. This RAM isn’t plentiful enough or fast enough to use the same way a general-purpose computer uses its framebuffer, but it does let us output pixel data at whatever rate we like.
Secondly, we could make a classic memory vs. time trade-off. The NES has additional processing in the PPU which lets it use less memory to store graphics in its cartridge ROMs. But if we’re okay with storing those graphics in a much larger form, we can avoid performing some of those processing steps. I chose to use a parallel Flash memory chip to store pixel data in exactly the same format that the LCD module expects it in. By wiring up the flash memory, LCD controller, and CPU in a clever way, I gave my firmware the ability to send bursts of contiguous pixels directly from Flash to LCD by simply counting upwards on one of the CPU’s 8-bit I/O ports.
It’s worth noting that this was a fairly extreme memory/time exchange. Classic game consoles stored the pixels for each tile at a very low color depth, typically 1 to 4 bits per pixel. We would need to use our LCD’s native 16-bit format. This makes our graphics a full 8x the size of equivalent graphics in a NES cartridge. We can compress this data when it traverses the radio link, but it must remain uncompressed in flash memory. Thankfully, in modern terms the amount of memory we need is small. We use a 4 MB flash device which can store 32,768 tiles.
At this point, we had a promising combination. The hardware was all commonly available and relatively DIY-friendly, the CPU would have enough time to draw multiple layers of tile graphics with several sprites, the total cost was within budget, and I had a software simulation with the debugging and unit-testing features we would need in order to take this platform from a proof-of-concept to a product. Now it just needed to run games.
Burning the Candle at Both Ends
To make this project work we were asking a chip no more powerful than an Arduino to compose smooth 2D video, a task well beyond its pay grade. On the other side of the radio link, another processor would be running our games.
The processor we chose is a 72 MHz STM32 with an ARM Cortex-M3 core. It’s almost the same chip used in the Maple. We were familiar with these processors from using them in the first generation of Sifteo Cubes. But now, instead of running the cubes themselves, this processor was running our games. Yet again we found an economic sweet spot where our job seemed possible, if inconvenient.
This chip has 64 kB of RAM, 128 kB of built-in Flash, and no hardware memory protection or paging. We added an external 16 MB serial flash chip for storing games and saved data. It would have been wonderful to have an MMU and a microSD card slot, but our design choices were ruled by power consumption. The base needed to run all day off of two AAA batteries, while the vast majority of that power went to the radio and speaker.
This chip needs to simultaneously run downloaded games, stream data from our low-power serial flash, synthesize music and sound effects, and communicate with over a dozen cubes. It would need to give us everything it’s got.
Safety Dance
When it came to running downloaded games on this CPU, none of our options looked good. For many months, we had been sidestepping this problem by compiling our games directly into the Base’s firmware. But re-flashing the CPU to run each game was really no good. It would be slow, the size of a game would be seriously constrained, and it would wear out the built-in flash memory relatively fast. Even during development, this kludge became a major thorn in our side. At one point Liam spent a hellish week porting our codebase to a larger microcontroller when we ran out of flash, just so we could continue our scheduled tests and demos.
We could copy games from external flash to RAM and execute them there. That limits a game’s size even further, since RAM is our most constrained resource. Additionally, all of these solutions allow games to have full, unrestricted access to the Base’s hardware. This may sound like a good thing at first, but such low-level access has consequences. Any game you download from the store could, either accidentally or maliciously, configure the system’s hardware in a way that would permanently damage it. This was something we wanted to avoid if at all possible!
This low-end CPU didn’t give us any way to protect our hardware from buggy or malicious games, nor did it give us a way to stream code and data in from external flash. So, I did what seemed natural when faced with a machine that’s missing some key capabilities. I built a virtual machine inside it.
Direct Execution
Virtual machines are a complex topic, and there are a few different axes along which you can categorize VMs. First, what does it run? Some VMs are designed to exactly emulate an existing computer architecture. Some VMs are designed to run a particular programming language, and the specifics of the compiled code are more of an implementation detail. And further still, some VMs are designed to mostly emulate an existing computer architecture, but with allowances that make it easier to virtualize. This last category is often termed paravirtualization, and it’s the chief strategy used by the Xen hypervisor.
Second, how does the VM run code? The simplest VM would use emulation. In software, it would fetch and decode the next instruction, then perform a sequence of operations that models the machine in question. This strategy works with any combination of virtual and physical machine architectures, but it’s very slow.
The ideal way to implement a VM would be with special-purpose hardware. This is how the first VMs ran on mainframes, and it’s the method used by most modern virtualization packages on desktops, laptops, and servers.
If you want the best performance possible but you don’t have special-purpose hardware available, you can compromise. This was the original approach used by software virtualization packages like VMware before the CPU vendors caught up. If you can determine ahead of time that a chunk of code is safe to run, you can directly execute it. In other words, the virtual machine’s instructions will run directly on the physical machine. For this to be safe, those instructions must have the same effect when run on the physical machine as they would have had running inside an emulation of the virtual machine.
PC virtualization packages like VMware have to make this determination on-the-fly. But our system could act more like the kind of special-purpose VM one might build for a new programming language. We could engineer the virtual machine such that the extra work necessary to make code safe can be done ahead of time, by the compiler. When a game runs on our VM, we can perform a quick check to make sure the code is in fact safe, then we can use direct execution to run that chunk of code at full-speed. This works well if we can design the VM such that it’s very fast to validate the safety of some code, even if it’s slow to actually make that code safe.
In order to efficiently run large games using only a small amount of RAM, we divide the game’s code and data into small pages, which are fetched on-demand from external flash into a small RAM-based cache. Some of these pages contain data, and some of them contain instructions for the Virtual Machine. If a game tries to execute code from a new page, we can run a speedy validation algorithm on that page to ensure that all of its code is “safe”.
In our case, “safe” code only contains a small subset of the available CPU instructions. Safe code can only transfer control to other safe code within the same page. Many common operations can’t be performed using this small subset of instructions, so we rely on system calls into the firmware, asking it to do these operations on behalf of the virtualized code. System calls allow us to do additional safety checks at runtime.
This type of virtualization is most similar to Google’s Native Client project, a way of running untrusted code safely inside a web browser. Like Native Client, we rely on a specialized compiler to produce code which is easy to validate ahead-of-time. Unlike Native Client, our VM must operate without any hardware memory protection. This means that the subset of CPU instructions we allow is even more restrictive, and we do memory virtualization entirely in software. Our VM is slower than native code, but still much faster than the emulation approach used by other common microcontrollers like the Netduino and BASIC Stamp.
Greetz to the Demoscene
At this point, we had a graphics engine and a way to run downloadable games. But our gaming experience was really only half complete. We had no sound.
We considered various strategies for music and sound effects. For a while we were using the open source Speex codec to store compressed music. But remember, we’re on a really tight space budget due to our power constraints. Even with very high levels of compression, there’s only so much music you can store in a few megabytes. We needed to think differently about the problem. Instead of storing compressed music, we needed to synthesize music in real-time.
This is another problem that was solved a while ago in a different context. Many older video games would benefit from having a way to store music more efficiently, but the technique we used was most well-known in the demoscene, a community of creative coders who are masters at squeezing every drop of potential from the available hardware.
This is a Tracker, a type of music sequencer that originated on the Amiga in 1987. Trackers are based on sampling. Similar to how many electronic musicians create a track by reassembling samples of other recordings, a Tracker does this in real-time to assemble a full song from many tiny recordings of individual instruments. The memory used by these tiny recordings plus the pattern of notes would be far less than the memory used by a recording of the complete song, just as a MIDI file can be much smaller than an MP3. Unlike MIDI, Trackers give the artist exact control over how their instruments will sound.
There were existing tracker playback engines that almost fit the bill. ChibiXM, a tracker designed for iOS games, was close. But it turned out that our tracker needed to be closely integrated with our audio mixer and virtual memory subsystems to achieve the performance we needed. My colleague Scott Perry wrote a new tracker engine for Sifteo that was perfectly tailored to the project’s needs.
Fill the Toolbox
Along the way, we ended up writing a lot of custom tools. In fact, for every line of code in the system’s firmware, there was another line of code purely for development and test tools.
To generate code for our special-purpose virtual machine, I used the LLVM libraries to build a special-purpose code generator and linker. I wrote another custom tool to compress and optimize our graphics, using some of the same techniques used to compress video for the web.
The emulator I wrote originally as a proof-of-concept grew up into a full-featured platform simulator that forms the cornerstone of our freely available software development kit. I used an embedded Lua interpreter to add unit testing capabilities to this simulator. This is how we ensured the quality of our firmware builds before they ever met real hardware.
I faced some challenging speed vs. accuracy trade-offs when developing our simulator. It needs to be fast enough to use as a game development tool, but accurate enough to catch firmware bugs early. I designed the cube simulation with two execution modes: A 100% cycle-accurate mode which emulates each instruction, and a static binary translation mode in which entire basic blocks of microcontroller code are pre-translated to native x86 code. This latter mode is the default, and it is cycle accurate in most cases. In both modes, all hardware peripherals are cycle-accurate.
Simulating the Base is another story. We didn’t have as much incentive to write a cycle-accurate hardware model for it. The Base’s firmware and hardware design were much less risky than the Cube, and we expected to need less low-level debugging assistance. So on the Base side, we recompile the firmware with an alternate set of hardware abstraction libraries. These simulation-only libraries implement hardware features using the APIs available on the host operating system. Radio transactions are sent to another thread which runs the simulated cubes. Both simulated systems use a common virtual clock, and they synchronize with each other when necessary. The main disadvantage is a lack of precision in modeling the speed of the Base’s firmware. We find that this approach is still substantially bug-for-bug compatible with the real hardware, and it’s much more efficient than emulation. It happens to be the same approach used by Apple’s iOS simulator.
I’ve always believed in investing in good tools, whether they’re physical tools or software tools. Putting in the time early-on to build a powerful simulator and compiler would give us immense freedom to add powerful debugging and optimization tools. And I can’t overstate the importance of thorough unit testing. When you have confidence in your code’s correctness, you have so much more freedom to optimize it or refactor it.
Give Yourself a Lever Long Enough
Thank you for reading about our journey. It’s been quite a ride, and I hope you enjoyed this glimpse into it. It wouldn’t have been possible to create this new game platform without the immense effort of our entire team. I wanted to specifically thank my co-conspirator in all things firmware, Liam Staskawicz, and our electrical engineering team: Hakim Raja and Jared Wolff. Bob Lang was responsible for all things mechanical and manufacturing, and Jared Hanson built our end-user desktop software. And perhaps most amazingly, the whole games team did a fantastic job creating top quality experiences even though we pulled the rug out from under them on a weekly basis.
Any one section in this article could easily have been a whole chapter, and if you want to know more I’d encourage you to check out our documentation or contact me. We’re planning on posting more behind-the-scenes info on our projects at tech.sifteo.com, so check back there if you like. You can also download our free software development kit, or buy some cubes of your own.
This project involved an immense amount of work and a lot of creativity, but otherwise there wasn’t anything particularly special about what we did. We didn’t have million-dollar runs of custom silicon, we didn’t have any secret data sheets or proprietary code libraries. Just like all of the other hardware tinkerers and do-it-yourselfers out there, I built on common parts and open source tools. In that way, there isn’t a fundamental difference between our project and a DIY game console kit like the Meggy Jr.
I encourage everyone to take a critical look at the objects in their lives, and imagine how you could make them more personal, more magical, or just generally more awesome. Then look around you for ways to make that happen. At Sifteo, our “secret sauce” was really just creatively repurposing hardware to do things the designers never imagined. This is something anyone can do. I think the future of hardware is in creativity, not raw money or power. Creativity democratizes innovation.
Here’s a MaKey-MaKey project built around a wind chimes type instrument — run through Max6 to trigger chime-like tones and punch up the dynamics a bit. (via the makeymakey fourms)
I built a set of wind chimes using my Makey Makey (arrived yesterday!). I used Max/MSP to convert the keyboard inputs to MIDI notes and used a simple synth to produce chime tones. I wrapped some cutlery in foil to make it more conductive; forks as key inputs, knives as the ground.
Electric Wind Chimes using Makey Makey (Arduino) and Max 6. Hopefully this will be the first of many inventions
Every Monday is Makey Makey™ Monday here at Adafruit! The MaKey MaKey – by Jay Silver and Eric Rosenbaum, made by JoyLabz! Ever played Mario on Play-Doh or Piano on Bananas? Alligator clip the Internet to Your World. MaKey MaKey is an invention kit for the 21st century. Find out more details at makeymakey.com or watch the video at makeymakey.com. Turn everyday objects into touchpads and combine them with the internet. It’s a simple Invention Kit for Beginners and Experts doing art, engineering, and everything in between! If you have a cool project you’ve made with your Makey Makey be sure to send it in to be featured here!
RF has always been fascinating to me — there’s something magical about sending and receiving bits and bytes over the air at high speed, through walls and concrete, out into space and back, etc. While RF has a reputation for being complex — and it can get messy depending on what you need to do — there are a number of platforms, products and tools out there that make RF more accessible for hobbyists than it’s probably ever been before. This quick holiday gift guide will hopefully highlight some of the tools you have at your disposal if you want to get started sending bits and bytes over the air yourself! (more…)
Robots are increasingly being used in place of humans to explore hazardous and difficult-to-access environments, but they aren’t yet able to interact with their environments as well as humans. If today’s most sophisticated robot was trapped in a burning room by a jammed door, it would probably not know how to locate and use objects in the room to climb over any debris, pry open the door, and escape the building.
A research team led by Professor Mike Stilman at the Georgia Institute of Technology hopes to change that by giving robots the ability to use objects in their environments to accomplish high-level tasks. The team recently received a three-year, $900,000 grant from the Office of Naval Research to work on this project.
Laen has just opened up an online shop for PCBs created through the OSH Park service. The PCBs are sold with permission from the creators. While some of the PCBs may be on hand, it looks like many will be added to the next PCB order once you order it in the store. This is a great idea, and I hope everyone who submits their board to OSH Park opts-in.
Here’s an update from Daniel about Minecraft: Pi Edition from MineCon, via Raspberrypi.org, including some more details about what it means to add the programming access into this special version:
What do you get when you combine Mickey Mouse, some game developers from Sweden, and an inexpensive educational computer? Good news all around! I was at MineCon in Disneyland Paris this weekend where we unveiled an early version of Minecraft: Pi Edition.
This new version is based on the Pocket Edition of Minecraft, which you may have seen running on mobile phones and tablets, but has one key difference: you can program it. All you have to do is set up a network connection to the running game, and then you can send text commands to control the world. This makes is possible to program in any language which supports network connections, and you can access the game from any computer which is connected to the Pi. One possible setup is to have a Python prompt and the Minecraft window side-by-side on the Pi.
Minecraft: Pi Edition has been in development for less than a week, but already Daniel and Aron from Mojang have got it running really smoothly. It runs on all versions of the Raspberry Pi with no overclocking necessary. There’s currently the ability to place any block at any location, ask what type of block is at any location, and keep track of events such as player movements, with more features planned.
We see this as a very exciting way of drawing children into programming. The game can be played with no programming at all. Then, basic programming can be used to place large numbers of blocks in particular patterns to speed up the building process – the audience burst into applause when Daniel wrote a simple loop which simultaneously changed the position and type of blocks being placed, which soon resulted in lava cascading from mid-air and setting fire to the wood below. The more creative programmer will only be limited by their imagination. Want to build a digital clock into the wall of your house which displays the real time? Easy. Want to get back at a friend who stole your precious diamonds? Remove the floor from underneath their feet and let them fall into a pit of lava. The possibilities are endless.
The goal is to release Minecraft: Pi Edition before the end of the year, free of charge. We hope that this will further advance the Raspberry Pi’s aims of getting children excited about computing.
Here are some more items for young girls, from books and electronic LEGOs to free iPad games, created by engineers who want to help change the ratio in math, science and computer classes everywhere. And hopefully soon, this ratio will change in company boardrooms, engineering departments and science laboratories everywhere.
If you’re serious about electronics and engineering, you’re going to need some tools to help poke, prod, measure and coerce all those stray electrons into going to their proper destination or tracking them down when they go astray. While hardly exhaustive, this guide will hopefully point you to some of the keys tools you might need to design, build and test things more efficiently.
I’ve tried to list them in the order that I think they should be acquired from most frequently used to more specialized gear, but obviously it depends on what you’re trying to accomplish. Where relevant, I’ve tried to list at least two models, one lower cost but reliable option for people getting started or intermediate users, and one professional device that I know is tried and tested if you need something that you can rely on day in and day out year after year when the numbers really matter. (more…)
Check out the first live demo of the Raspberry Pi camera module that Rob Bishop has been working on this year, via DesignSpark:
The camera module is a 5 megapixel camera phone sensor that plugs into the Raspberry Pi via the onboard camera connector interface. Using CSI for data and I2C for control, the camera module will allow users to record 1080p at 30 frames per second in H264 video format.
Thanks again to Rob Bishop (below) of the Raspberry Pi Foundation for helping us set this up. To demo the camera we attached the “Pi-Cam” to a make shift boom arm and then streamed HD video of people playing our Raspberry Pi Batak Game, which challenged contestants to get the fastest time to win a Raspberry Pi bundle. The game was very popular and at times extremely competitive!
The Raspberry Pi camera should be available soon, hopefully not long into the New Year. We believe it will be priced around the same as a Raspberry Pi, and will be on sale at RS Components. The camera will allow users to very cheaply add an HD video input to their projects for anything from robotics to home security systems.
The Raspberry Pi Foundation has just announced their Summer Coding Contest winners and runners up here.
Summer Coding Contest. We’d hoped to have the results ready weeks ago, but there were so many excellent entries to go through line-by-line that it’s taken us a little while; we were blown away by some of what you did. If you’re a winner, your prize will be on the way soon, just in time for Christmas. And if your winning software is available online somewhere (not all of it was) and we’ve missed it, please drop me a line so I can add a link to this post.
The first prize in both categories is $1000, with runners-up prizes of $200 in each category. Well done to all the winners, and thanks to everybody who entered. We look forward to doing this again!
The MakerBot Store received a re-launch earlier this week, and they added a bunch of new elements. They added a 3D Photo Booth built around a ShapeShot scanner allowing visitors to get a scan of themselves for a fee, and then pay to print out their own heads. While not as startling a copy as the Japanese pop-up store we featured last week, still a great opportunity for visitors to NYC looking for a replica of themselves!
Here are a few interesting details of the re-launch via Techcrunch:
Most of the objects in the store have been designed within the previous week and printed over the previous two days. Such a short product cycle is something new in manufacturing. With the store, it’s all about making 3D printing mainstream.
“My hope is that the next lemonade stand for kids will be a MakerBot stand,” Pettis said. For now, NASA and GE are the two most important clients, and four of the top ten architectural companies use a Replicator. MakerBot has sold 15,000 printers so far.
Buckets of Bre-heads! Hmmm. Are those for sale? Or display only?
A container of stretchy bracelets designed by talented Emmett Lalish, a favorite first print for 3D printing enthusiasts for $5 a pop!
Beautiful MakerBot Watch designed by Matt Kroner, John Briscella, and John Dimatos.
Cute, helicopter assembly designed by Matt Kroner and Chris Boynton — from this week!
Every Thursday is #3dthursday here at Adafruit! The DIY 3D printing community has thrilled us at Adafruit with its passion and dedication to making solid objects from digital models. Recently, we have noticed that our community integrating electronics projects into 3D printed enclosures, brackets, and sculptures, so each Thursday we celebrate and highlight these bold pioneers!
Have you take considered building a 3D project around an Arduino or other microcontroller? How about printing a bracket to mount your Raspberry Pi to the back of your HD monitor? And don’t forget the countless EL Wire and LED projects that are possible when you are modeling your projects!
The Adafruit Learning System has dozens of great tools to get you well on your way to creating incredible works of engineering, interactive art, and design with your 3D printer! If you have a cool project you’ve made that joins the traditions of 3D printing and electronics, be sure to send it in to be featured here!
I began my second set of goggles a couple of weeks ago and have since finished all the neat cosmetic parts on the exterior. Just like the name suggests, they are all in black and white, one eyepiece black with white trim, the other eyepiece its opposite.
With the artsy part finished, this weekend I started on the electronic portion and wired up a breadboard with all my componants : three bat switches for each color channel of an RGB LED and a toggle button to switch between the LEDs housed in the two separate eyepieces.
For this project I am using the ATTiny 2313 microcontroller, supplied to me by Krux. As I have never used anything other than the arduino, he is also helping me yet again with the programming portion. This is a learning experience for both of us, so hopefully I can jump up the latter as quickly as he can on this one. (As always thank you for the help!).
Every Wednesday is Wearable Wednesday here at Adafruit! We’re bringing you the blinkiest, most fashionable, innovative, and useful wearables from around the web and in our own original projects featuring our wearable Arduino-compatible platform, FLORA. Be sure to post up your wearables projects in the forums or send us a link and you might be featured here on Wearable Wednesday!
Now all the major pieces of your Hackerspace are in place. The paint has (mostly) dried, your toilets flush properly, and you’re pretty sure your new programmable LED strips are installed properly. Now what do you do?
Well… How about a celebration?
A launch party – large and exciting, or private and warm – is a great way to mark the occasion with your community, and set an excellent tone. For Pumping Station: One, the founding members organized a “Geek Prom” party where everyone could let their hair down after a year of hard work.
But that’s just one example: You can do any number of different events that will please your co-hackers, and any guests that join your celebration.
Examples for a Hackerspace launch event:
Hackathon
Fundraiser
Futher buildout
Movie screening
BBQ – hackers gotta eat
Science fair
Plus many more….
Each of these events can be a fundraiser for your space if you’d like. At the same time, some Hackerspaces might choose not to have a launch event for various reasons. Like everything with your Hackerspace, it’s an individual thing and the choice is up to you.
Hackerspaces: Made by, and for, all of you
A Hackerspace is created only by the effort and resources that you and your co-hackers put into it. Set out to make your space amazing for you and your community – and it will be. When I set out to build Hackerspaces, I did nothing but dedicate my time to making sure that each space I worked with had the best chance to succeed and grow (while keeping my day job, of course – at the time). I hope you can pour the same optimism into your Hackerspaces’ potential as I did.
Looking onward with this series – there’s a lot more that I’ll be covering in future posts for this How To Start A Hackerspace series on the Adafruit blog. The series is not just about starting Hackerspaces, but will be growing to include details on starting out and making your space a success. Here are a few examples below of upcoming posts:
Building community
Funding and income
Bank stuff, payment processing
Formation paperwork and insurance
How to setup your Electronics/Textiles/Metal/Wood/Hacker Lounge/Etc areas
These posts are Creative Commons. They are made for sharing. Pass them far and wide, and add to them if you wish.
Hackerspaces are made by everyone, and I’ve done my Hackerspace work with many amazing people – this taught me how important feedback and collaboration is for Hackerspaces and Hackerspace culture. Feel free to email me at hackerspaces@i11industries.com with suggestions, and I’ll do my best to include that information so we can all work toward making Hackerspaces as ubiquitous as public libraries.
No matter what stage your business is in – just starting, recently launched, ready to scale – this year’s festival is designed for you. There is nothing more important to an entrepreneur than good information, sound advice, a supportive and generous community of peers, and great conversation. This year we focus on the nuts and bolts: what you need to know to make your business a success from people who have been where you are now.
The goal of the WE Festival remains the same. We hope to sow the seeds for a community of women entrepreneurs; to expose women who have not yet taken the entrepreneurial leap, the pre-entrepreneurs, to women who have.
Each week on the Adafruit blog we post up about amazing companies, people and articles about being a MAKER and a business. Over the years we’ve shared how we run Adafruit, published code from our shopping cart system and given presentations on running an open-source hardware company. Every Monday we’re going to try to collect some of these resources and tag them #makerbusinessmonday & #makerbusiness they’re in our popular Maker Business category as well, enjoy!
If you’ve been reading my blog for a while, you’ve probably noticed that I typically make my own PCBs for my projects. I’ve gotten much better at this process over the past few months, and I’ve been promising a “super awesome writeup” on my techniques for almost a year now. I figured that a video would do more than a writeup and spent the weekend producing one for you.
So here you have it! The video is a good 40 minutes long, but it’s packed with details that should hopefully help you avoid some of the time consuming mistakes I’ve made.
Part of the Maker Education Initiative’s mission is to help spread the best practices, lessons learned, and research from maker programs around the world. We are working to build a database of maker education resources and research. If you have research, playbooks, curriculum, or other maker education resources that you would like to share, please contact us. It is our hope to launch this Maker Education Resource Database in early 2013, but we will add resources to the list of links below until then.
I would like to know if it is safe to use Li-Po batteries in series in order to provide a higher operating voltage. I was reading the Adafruit Learning System write up on Li-Ion and Li-Poly batteries and I got a bit confused.
The ALS says the following about charging Li-Pos in series:
“”This is also discouraged because the battery wont be able to be charged in a balanced manner. You should purchase a lithium ion pack that is preassembled.”"
I would like to know, if it is OK to use the batteries in series and then charge them individually.
Great question!
Batteries are purchased in two configurations, as individual cells (i.e. an AAA, AA, C, D, 18650, etc) or as a pack. Individual batteries do not need to be balance charged as the charger will regulate the voltage and current input to the battery and turn off when complete. The Adafruit Learning System’s statement is based on the fact that some battery chemistries do not “self-balance” when charged in series. In contrast, chemistries like NiMh and NiCd can be charged without balancing.
If you purchase a Lithium based battery pack containing 2 or more cells, it should have secondary wires that are connected to each respective cells positive and negative terminal. Each wire is shared with its neighbor, so a 2S pack would have 3 wires, a 3S pack would have 4 and so on. These taps allow for “fine tuning” the current and voltage entering the pack during charging and maintains a constant voltage over each cell. Make sure you have a battery charged that is designed to charge multiple lithium cells and that it contains this balancing capability. Below is an example of what can happen if a LiPo battery is improperly charged:
In order to prevent a disaster like this, periodically examine the physical state of your batteries. They should not feel squishy or appear ballooned and make sure you store them in a fire-proof container. I happen to use a old coffee can for mine. If you find out they are damaged, bring them to your local hobby store for recycling.
There is a great website that provides quite a bit of information regarding the proper handling of most battery chemistries.
I hope this has helped answer your question, have fun with your LiPos and be safe!
Don’t forget, everyone is invited to ask a question!
“Ask an Educator” questions are answered by Adam Kemp, a high school teacher who has been teaching courses in Energy Systems, Systems Engineering, Robotics and Prototyping since 2005.
A mere 6 months since we launched the Adafruit Learning System, we are pleased to announce that we have already deployed what we are calling version 2.0. In the last six months, the tiny crew that is in charge of Adafruit Learning Technologies has been hard at work. We quietly launched the Adafruit Learning System in early June with just a few guides. Since then we have deployed numerous tweaks, upgrades, and bug fixes to make the system better. We believe we have the best learning system on the web, and now have almost 100 published guides to help you learn something new.
After the launch of the Adafruit Learning System, it always felt to me as if it were still a wireframe design. My design focus has always been to emphasize the guides themselves, but I still thought the ‘wrapper’ needed work to not be so bland. I also liked the endless scrolling of the homepage, but wanted a better way to curate content so we could bring attention to certain guides, and highlight our favorite older guides. I immediately started working on new wireframes and design ideas. It took about 13 attempts before I finally locked in on the design you see today.
With this new design, we now have continuity between the homepage, and the guides themselves. We also have featured guides on the homepage sidebar, and a list of the most popular guides in the Adafruit Learning System.
Overall, we are very pleased with the look of the new Adafruit Learning System, and hope you are too. Even though we are already at version 2.0, we are just getting started. We have so many cool features and updates planned, and we can’t wait to share them with you.
On Saturday, I dropped off some supplies at a Hurricane Sandy shelter at Rutgers University. Included among the items were 20 of the Adafruit coloring books, each bundled in a bag, along with a pack of crayons (above). Phil (pt) was kind enough to overnight the coloring books to me, so that I could include them in my care package. It felt really great to do something to help out my New Jersey neighbors, many of whom are still without power or access to their homes, and in some cases have lost everything.
Finally, I’d like to give many thanks to all the people around the world who have already given their support! Thank you on behalf of the Garden State!
If you’ve ever wanted your own place to work on projects, learn a new skill, build a new company, or to co-hack with others for camaraderie or info sharing, then it’s time to start a Hackerspace.
There are hundreds of Hackerspaces around the world and growing, they come in many different flavors, and they are used by all kinds of hackers. These posts provide the basics on how to set up your own space, no matter what kind of hacker you are, and is inclusive of the different kinds of hackers you hope to share your space with.
Map of Active Hackerspaces as of 11/12/12
This guide – which will be expanded and detailed in upcoming posts – will hopefully show you that the only limitations for your dream Hackerspace and the hacks you and your co-hackers can do are the limits of your imagination.
Hackerspaces are for all the hackers.
Hackers come in all ages, sizes, genders, and from all backgrounds and skill levels. Your first step is to identify who your space is going to be for: who is putting the space together, and what kind of hackers will be wanting to hack there?
It’s essential to narrow down who the space is for when you first start out, even if you plan on including a lot of other kinds of hackers in the future – make a solid core! Is the space primarily for computer hacking, hardware hacking, or do you have people that hack in a variety of materials? The answer to “who” will come from you – and also the people you’re starting the space with.
Take a look at other Hackerspaces you admire or are inspired by. Check out what other hackers have done at global resource hackerspaces.org, and find shared info and wisdom at hackerspaces.org/wiki/Documentation.
Nailing down who the space is for (you and your co-hackers) gives you key information to make important decisions about the space itself, the tools you need and the resources you need to put together.
Examples of who your Hackerspace might be for:
Computer hackers
Hardware hackers
Food hackers
Metalwork hackers
Chem hackers
Textile hackers
Multimedia hackers
UAV hackers
Now that you know which hackers may initially populate your Hackerspace, you’re ready for the next step.
Moritz Simon Geist is really good with wires. He has transformed the famed TR-808, one the first programmable drum machines and main supplier of sounds for rap music, into a full blown robot entitled “MR-808.” The entirely mechanical installation uses robotic arms in conjunction with an Arduino micro-controller and Albeton sequencer — for all your technophiles — allowing the users to remotely control it. The structure also mimics that of a drum machine. Geist intends to use the installation during on stage performances as he hopes to improve the electro-pop genre.
Mothership HackerMoms http://mothership.hackermoms.org gives moms the time and space to explore DIY art/design, craft, tech, business and all manners of creative expression — with childcare on site. We are artists, makers, designers, writers, scientists, programers, educators, as well as mothers. Our non-profit hackerspace is located in Berkeley, CA. We are the first women’s hackerspace – ever… and we don’t want to be the last.
We made a funny, moving Kickstarter video about creativity and motherhood that people (not just moms) seem to really like. We have just 7 days left to reach our “stretch” goal to fund a DIY workshop, equipment and tools, a mini maker program and community outreach support. Our end date is right around the corner, Nov 18th.
We have big love for your site and your mission. I hope you will support us by sharing/tweeting/fb our story. Thank you!
An interesting initiative from MAKE to encourage makers around the world to gather physically and via Google+ Hangouts On Air to discuss the latest MAKE issues. The first session will feature the 3D Printing special issue (I helped with this one!):
Next Thursday, the first of our new International Maker Meetups is happening. The idea here is to get makers all over the world together, to talk about the latest issue of MAKE, and making in general, hang out with like-minded people in your area, and hopefully have a lot of fun. The main subject of this meetup will be 3D printing and our just-printed Make: Ultimate Guide to 3D Printing. We will be hosting a face-to-face meetup here in Sebastopol and other people are creating their own meetups around the world. We will also be doing a Google HOA at 6pm PST/9pm EST on the 15th that you can tune into and and perhaps become a part of. Participants at the meetups will get a free PDF copy of the Ultimate Guide to 3D Printing. If you want to set up a meet up in your area or want to join one, visit the MakerMeetup page. We hope you’ll participate.
Whether you’re a designer, inventor, hacker, tinkerer, or weekend DIYer–anyone interested in finding out more about 3D printing and design is welcome! We suggest getting together at convenient locations such as a hackerspace, coffee shop, community center, library, or restaurant. Bring your laptops, tablets, smartphones to access the Internet and G+ Hangout On Air. The first 25 organizers will receive a MAKE meetup welcome kit that includes: 12 copies of the MAKE Ultimate Guide to 3D Printing, MAKE T-shirts, notebooks, stickers, and buttons. The top 3 organizers with the highest number of RSVPs will get a $200 stipend for beverages and food!
Every Thursday is #3dthursday here at Adafruit! The DIY 3D printing community has thrilled us at Adafruit with its passion and dedication to making solid objects from digital models. Recently, we have noticed that our community integrating electronics projects into 3D printed enclosures, brackets, and sculptures, so each Thursday we celebrate and highlight these bold pioneers!
Have you take considered building a 3D project around an Arduino or other microcontroller? How about printing a bracket to mount your Raspberry Pi to the back of your HD monitor? And don’t forget the countless EL Wire and LED projects that are possible when you are modeling your projects!
The Adafruit Learning System has dozens of great tools to get you well on your way to creating incredible works of engineering, interactive art, and design with your 3D printer! If you have a cool project you’ve made that joins the traditions of 3D printing and electronics, be sure to send it in to be featured here!
Developing a beautiful printer, great materials, easy to use software and a finish kit to tie the experience together is very time-consuming. Keeping track of all these different parts in production has been a challenge. In terms of actual mechanical engineering though, our biggest challenge was imagining SL printing for the desktop and how to make that experience as user friendly as possible. There are lot of subtle details that we hope users will appreciate from the grip on the build platform to getting just the right amount of friction in the hinge for the cover and the audible ‘click’ when a resin tank is inserted securely. Small details like that are important to us and we believe it goes a long way towards making the experience for our users even better.
Every Thursday is #3dthursday here at Adafruit! The DIY 3D printing community has thrilled us at Adafruit with its passion and dedication to making solid objects from digital models. Recently, we have noticed that our community integrating electronics projects into 3D printed enclosures, brackets, and sculptures, so each Thursday we celebrate and highlight these bold pioneers!
Have you take considered building a 3D project around an Arduino or other microcontroller? How about printing a bracket to mount your Raspberry Pi to the back of your HD monitor? And don’t forget the countless EL Wire and LED projects that are possible when you are modeling your projects!
The Adafruit Learning System has dozens of great tools to get you well on your way to creating incredible works of engineering, interactive art, and design with your 3D printer! If you have a cool project you’ve made that joins the traditions of 3D printing and electronics, be sure to send it in to be featured here!
My friend Aaron Juarros & I decided to cast an old fried Arduino in bronze to serve as a trophy to DIY types. The source Arduino led a good life as an educator (it was fried by students at New Mexico Highlands University).
Our first run of ten is bound for the 2012 MCN Conference in Seattle. We will be donating one to the MCN Silent Auction (proceeds benefit MCN Scholarships).
The tornado costume was a success!
The mechanism was not as dependable as I would have preferred. The socket-set connections were good, but I should have welded the final upright link to the metal bolt inside the “propeller” crossbar at the top.
I shouldn’t have used fiberglas insulation. Spray paint helped keep it subdued, but the fibers still caught the air and broke free, flying around inside and outside of the costume. The fiberglas was irritating.
I’m happy to have created a new style of harness for a costume. I hope it inspires other rotating costumes in the future… and I hope I don’t have to compete against them.
[Stimmer] on the Arduino Forum hardcoded a way to display 160×240 (320×240 after some posts) VGA signal:
“After working out how to do a timer interrupt I’ve had a go at making a VGA framebuffer. It is rather low-res at present(160×240) and fuzzy but I hope to be able to improve that. It has 8-bit colour (RRRGGGBB).
“I cannot get Eagle to run right now so will have to describe the schematic in text:”
Put your Arduino project on TURBO mode with the high-speed, high-power Arduino Due! The Due cranks it up to 11 with an 84 MHz ARM core processor – 512K of FLASH storage! 96K of RAM! Both USB client and host! The Arduino Due is ideal for those who want to build projects that require high computing power. For example, remotely-controlled drones that, in order to fly, need to process a lot of sensor data per second – or an audio player that uses the built in Digital-to-Analog converter.
The Arduino Due also gives students the opportunity to learn the inner workings of the ARM processor in a cheaper and much simpler way than before.
To scientific projects, which need to acquire data quickly and accurately, Arduino Due provides a platform to create open source tools that are much more advanced than those available now.
The new platform enables the open source digital fabrication community (3d Printers, Laser cutters, CNC milling machines) to achieve higher resolutions and faster speed with fewer components than in the past.
Main features of Arduino Due
The board is equipped with a SAM3X8E processor from Atmel, based on the 32 bit ARM Cortex M3 architecture running at 84MHz.
USB 2.0 interface running at 480 Megabits that allows Arduino Due to act as a USB Host (so you can interface it to USB devices like mice, keyboards, cameras, mobile phones and more). Arduino Due supports the Android ADK 2012 protocol.
12 analog inputs (ADC) with 12-bit resolution and high speed, opening the door to audio applications and signal processing projects that were impossible with Arduino Uno.
High-resolution Analog outputs (DAC). The board provides two 12-bit outputs that can be used to generate audio signals. The Arduino Due software comes with software examples for a WAV and OGG player.
4 high-speed serial communication ports.
70 input/output pins.
High-speed CAN interface. The CAN protocol is used in the automotive industry to network the different components of the car, is now becoming popular in the field of industrial automation thanks to its speed and ability to withstand electrical noise.
“Hope you are well – thought I’d share some news today as ThingMagic, recognizing that RFID plays a significant role in the Internet of Things and making Big Data actionable, is introducing the smallest, highest performing RFID reader module that meets the growing demands brought about by a more mobile workforce. In fact, the company depicted the Future of RFID in an Infographic.
“If a stock room employee can carry an RFID reader in his back pocket while going from store room to store room, he’s more productive and efficient. If a parking garage owner can mount an RFID reader on a pillar of an old structure, he is not required to make any structural changes. At only 46 mm long and 26 mm wide, the Mercury6e-Micro offers more flexibility for various uses and environments….”
Adafruit PN532 NFC/RFID Controller Shield for Arduino + Extras
NFC (Near Field Communications) is a way for two devices very close to each other to communicate. Sort of like a very short range bluetooth that doesn’t require authentication. It is an extension of RFID, so anything you can do with RFID you can do with NFC. You can do more stuff with NFC as well, such as communicate bi-directionally with cell phones
Because it can read and write tags, you can always just use this for RFID-tag projects. We carry a few different tags that work great with this chip. It can also work with any other NFC/RFID Type 1 thru 4 tag (and of course all the other NXP MiFare type tags)
The Adafruit shield was designed by RF engineers using the best test equipment to create a layout and antenna with 10cm (4 inch) range, the maximum range possible using the 13.56MHz technology. You can easily attach the shield behind a plastic plate with standoffs and still read cards through a (non-metal) barrier.
This shield is designed to use I2C or SPI communication protocols. I2C is the default, as it uses fewer pins: analog 4 and 5 are used for I2C (of course you can still connect other I2C devices to the bus). Digital #2 is used for “interrupt” notification. This means you don’t have to sit there and ‘poll’ the chip to ask if a target tag has been found, the pin will pull low when a card, phone, etc is within range. You can adjust which pin is used if you need to keep digital #2 for something else. It is also easy to change the shield over to SPI where you can use any 4 digital pins by shorting two solder jumpers on the top of the PCB. Compatible with any “classic” Arduino – NG, Diecimilla, Duemilanove, UNO – as well as Mega R3 or later. For using the I2C interface with Mega R2 or earlier, two wires must be soldered as the I2C pins are in a different location on earlier Megas.
A while ago, I designed a DIY kit that let folks dig up their old typewriters and put them to use as USB computer keyboards or as iPad docks. Even though that kit worked great, the hardest part by far was the soldering. Many people wanted to know if there was a way to put together the kit without doing any soldering at all.
So this summer I designed an “Easy Install” version of the USB Typewriter kit, which now involves absolutely no soldering or special tools and is just plain easier to install all around. This guide explains the installation process for my new kit, which is now available for sale at www.usbtypewriter.com. I hope you like it!
Update: Parts of southern NYC getting power, no power at Adafruit yet. Our home now has power so we’re getting back there now but our building in SoHo is still without power due to the explosion on 14th street. The expected time for power restoration in 1-2 days.
Pictured above, the current subway outage(s). NYC also canceled the marathon on Sunday.
We’ll keep updating, the good news is – we return home tonight and there is lights. Next up, Adafruit factory we hope!
Pictured above Ladyada navigating up and down the stairs without power at home office and later riding bicycle checking in on our factory without power in SoHo, NYC. Empty loading docks
Adafruit is still without power today, it is estimated that it will be back on within the next couple days – but there are a lot of unknowns and damage to the area(s) we hope to get our staff back in once the power is back on and the building is cleared to be safe.
We are not shipping today, but once we get power and net access we’re going to work 24/7 to get all orders out. We are working with the building management, USPS and UPS to resume shipping the moment it’s possible.
The latest from Con Edison“ALL of lower/mid Manhattan is expected to be back by Saturday.”
Ask an Engineer and show-and-tell is canceled for Saturday 11/3/2012. If we happen to get power and net we’ll broadcast us shipping and making products. We had a few new product launches that are now delayed, but we’ll get back to them the first possible moment.
Thank you again for all the support, concern and patience. We will keep updating. The customers, community, partners and everyone out there are amazing, thank you thank you so much.
In Minecraft there are a variety of monsters, the most troublesome of these is the “Creeper.” Creepers are plant monsters who explodes when they get next to you usually leaving a crater in the aftermath. Woe to the player who is surprised by their distinctive SSSSSSSSSSSSSSSSBOOOM!
In respect to Minecraft’s king of monsters I and some of my cohorts thought it would be entertaining to undertake a project to build a creeper prop with some animated features for Holloween this year. Our hope is to give an authentic creeper experience to some trick-or-treaters! Naturally, making robocreeper actually explode is not something we can really do in our urban environment, but we can load the thing with RGB LEDs, motors, motion sensors, and a loud speaker that will let you know when you have entered the blast zone!
Thanks to Brian Howland for this great video of his PumpkinHead Animatronic project that he had hoped to share during the Halloween Show & Tell!
It uses: Boarduino, Audio Shield, 16 ch servo board, RGB LED Strip and some preliminary software based on your examples.
Show & Tell is great stuff! Great to see so many folks building stuff. I am mostly by myself here in Iowa as a Maker. I will try to get on the show another time.
We look forward to having you on next time!
HAPPY HALLOWEEN! Each day this month (Monday-Friday) we’re going to have a special “Electronic Halloween” post here on Adafruit. It will be a hack, mod, project or something we’ve found that combines all the best things about electronics and Halloween.
Over the years, I’ve soldered a fair number of boards. I’ve also seen how professional factories produce their boards. This is my technique for doing it myself, and I hope it works as well for you as it does for me. :) Note: the files needed to make the fixture, custom pcb setup, and stencil are on Github – Stencil8. This whole project is OSHW.
Quick post to help those new to the physical computing ecosystem recognize microcontrollers, prototyping platforms, single board computers (SBC), and embedded systems out in the wild, via Ask MAKE:
…a lot of people wonder the same thing about the various physical computing devices we use for making. To start simply, a microcontroller is a small computer that is built into a single chip. It has its own processor, memory, and programmable I/O pins. The Arduino is often referred to as a a microcontroller, but that’s not entirely true. It uses an ATMega chip as a microcontroller, which is surrounded by circuitry that makes it easy to use and program. It can be properly called a prototyping platform that’s based on a microcontroller.
An embedded system is a small computer that is usually non-programmable by the average user, but functions in a similar way to any other microcontroller system. Embedded systems are most often used in existing consumer electronics, such as cellphones, MP3 players, even your microwave.
A system or computer on a chip is an entire computing system that fits onto a single chip (or IC). The difference between this and a microcontroller is one of degree. A system on a chip is generally more powerful and capable of running entire operating systems rather than just being able to execute discrete actions.
The Raspberry Pi uses the Broadcom BCM2835, which is considered a system on a chip. Hardware is built around this for easy prototyping – similar to the Arduino, but more robust and sophisticated (onboard SD storage, A/V outs, etc.) With all these capabilities, the Raspberry Pi is considered a single-board computer, with a system on a chip at its core.
I hope this clears things up for you. These technologies are obviously still burgeoning, so if anyone cares to weigh in with more (or different) knowledge, please do so in the comments.
I always been fascinated by the raw musical power that an orchestra can express, so, after creating a series of videos where I’m performing a multi-track piece with an instrument I designed, I decided to take the concept a step farther and create my own orchestra made of unusually unique instruments.
The project started by handcrafting a diverse selection of instruments, then I wrote a composition where I could fit them all in and finally performed each part. I hope you’ll enjoy it as much as I enjoyed doing it! – Diego Stocco
The Girls Who Code Inaugrual Gala was at the New York Stock Exchange was on October 22, 2012. It was in support of young women who are New York City’s future entrepreneurs and engineers, they unveiled the apps they built during the Girls Who Code program. The evening began the Social Investor Presentation where the Girls took over the NYSE Boardroom to pitch their creative technology and ability to change the future. The pitches were then followed by a networking reception and demos on the NYSE Trading Floor. Ladyada and pt stopped in and took some photos, it was PACKED! This was the first time any of the Adafruit team has visited the NYSE Trading Floor! Congrats to all the young women who are heading in to engineering because of this program!
WHO WE ARE
Girls Who Code is a new organization working to educate, inspire and equip 13- to 17-year-old girls with the skills and resources to pursue opportunities in technology and engineering.
WHAT WE DO
Together with leading educators, engineers, and entrepreneurs, Girls Who Code has developed a new model for computer science education, pairing intensive instruction in robotics, web design, and mobile development with high-touch mentorship led by the industry’s top female developers and entrepreneurs.
WHY WE DO IT
Today, just 3.6% of Fortune 500 companies are led by women, and less than 10% of venture capital-backed companies have female founders. Yet females use the internet 17% more than their male counterparts and represent the fastest growing demographic online and on mobile, creating more than two-thirds of content on social networking sites. Technology companies with more women on their management teams have a 34% higher return on investment, and companies with women on technical teams increases teams’ problem-solving ability and creativity.
The numbers speak for themselves. By 2018, there will be 1.4 million computer science-related job openings, yet U.S. universities are expected to produce enough computer science graduates to fill just 29% of these jobs. And while 57% of bachelor’s degrees are obtained by women, less than 14% of computer science degrees are awarded to women.
Host Committee – Master Gardeners
Jack Dorsey, Founder, Twitter, Square
Arianna Huffington, Huffington Post
Chris Hughes, Co-founder, Facebook
Beth Comstock, CMO, General Electric
Alexis Maybank, Founder, Gilt Groupe
Marisa Ricciardi, SVP Global Marketing, NYSE Euronext
Gina Bianchini, Founder, Ning, Mightybell
Craig Newmark, Founder, Craigslist
Hope Taitz, Board Member, Athene, Apollo Residential Mortgage REIT
David Hirsch, Metamorphic Ventures
Sunny Bates, Sunny Bates Associates
Evan Korth, Founder, hackNY
Andrew Rasiej, Personal Democracy Media
Kelly Hoey, Founder, Women Innovate Mobile
Greg Gunn, Founder, City Light Capital
Rachel Haot (Sterne), Chief Digital Officer, NYC
Nihal Mehta, Founder, Local Response
Steve Martocci, Founder, GroupMe
Caroline Ghosn & Amanda Pouchot, Founders, LevoLeague
Susan McPherson, SVP, Fenton
Jessica Lawrence, Managing Director, New York Tech Meetup
Kathryn Minshew & Alex Cavoulacos, Co-founders, The Daily Muse
Rachel Sklar, Founder, Change the Ratio & TheLi.st
Sponsors – Cultivators
NYSE Euronext
Twitter
Google
General Electric
AppNexus
AT&T
eBay
Goldman Sachs
D. E. Shaw
Raptor Capital
Global Grind
Schulte Roth & Zabel LLP
The Open Source Hardware Association will be an advocacy group, mostly educating people on what open hardware is, the benefits, and best practices, as well as being a roof for all the various items built by the community so far, including the Open Hardware Summit, the open hardware definition, and our logo.
There are a lot of excellent things done by the community that don’t really have a cohesive web presence to live under. We hope to give the community a bit of structure by organizing information around open source hardware under the Association. The other reason is that currently a lot of our knowledge about open hardware is colloquial… We hope to create a resource to make all these things more transparent and provide a formal entity that can answer questions about how, why, what, and the best practices of open hardware.
…
The board of the Open Source Hardware Association currently consists of Alicia Gibb (President), Danese Cooper, Catarina Mota, Windell Oskay, Nathan Seidle, and Wendy Seltzer. We are in the process of electing more board members with public nominations, but haven’t worked out the details yet. Please stay tuned!
All donations and membership dues (beyond the cost of providing specific benefits) will be used to support the Open Source Hardware Association’s public-interest purposes. [Dues may be tax deductible as permitted by law if our tax status is granted.] Memberships are valid for one year and priced in USD. Please review the membership levels below. Not ready to become a member? You can also donate to our cause! We are designing a corporate membership for similar levels. Current membership is for individuals only.
Join if you’d like to support the OSHWA. We are excited that a group is going to represent, help and educate regarding OSHW. Most of all, they’re going to represent and celebrate open source companies like Adafruit
Eric over at Low Voltage Labs has posted up his design for a simple PCB ideal for putting an LED into a pumpkin. This is very much like our simple LED pumpkin project but in a neat, reusable format. And it makes a mighty cute little jack-o-lantern all on its own.
He has made it available as a kit with PCB, switch, resistor, battery holder and the same candle flicker LEDs which we love so much. Unfortunately, the kit is currently sold out. Hopefully he’ll make more, if not in time for this Halloween, then at least for next year.
HAPPY HALLOWEEN! Each day this month (Monday-Friday) we’re going to have a special “Electronic Halloween” post here on Adafruit. It will be a hack, mod, project or something we’ve found that combines all the best things about electronics and Halloween.
Today we have some really big news, which is going to mean a lot to many programmers in our community who have been asking about it ever since launch. This is one of those announcements that has been in the pipeline for quite some time, but we haven’t been able to talk about it until now.
As of right now, all of the VideoCore driver code which runs on the ARM is available under a FOSS license (3-Clause BSD to be precise). The source is available from our newuserland repository on GitHub. If you’re not familiar with the status of open source drivers on ARM SoCs this announcement may not seem like such a big deal, but it does actually mean that the BCM2835 used in the Raspberry Pi is the first ARM-based multimedia SoC with fully-functional, vendor-provided (as opposed to partial, reverse engineered) fully open-source drivers, and that Broadcom is the first vendor to open their mobile GPU drivers up in this way. We at the Raspberry Pi Foundation hope to see others follow.
Everything running on the ARM on the Raspberry Pi is now open source.
NEW PRODUCT – “3 Laws of Robotics” poster, This glossy poster featuring ADABOT and Asimov’s three laws of robotics measures 18 x 24 inches. Comes packed in a cardboard tube for shipping.
MADE IN THE USA!
A robot may not injure a human being or, through inaction, allow a human being to come to harm.
A robot must obey the orders given to it by human beings, except where such orders would conflict with the First Law.
A robot must protect its own existence as long as such protection does not conflict with the First or Second Laws.
- Isaac Asimov, Handbook of Robotics, 56th Edition, 2058 A.D.
Adafruit’s posters are manufactured in partnership with AMBRO Manufacturing located in NJ, USA. AMBRO is a family owned and operated business since 1990 that celebrates open-source with Adafruit Industries. You can meet their team here. AMBRO uses non-toxic soy based, water soluble and environmentally friendly printing supplies, threads and more when possible. AMBRO has over 250 solar panels that generate 50,000 Kilowatt hours per year. Their equipment runs solar powered, so the wonderful things AMBRO and Adafruit have worked together on are made with the sun! AMBRO Manufacturing was recognized by Impressions Magazine, a leading trade publication in the garment printing and embroidery business, who published an article highlighting AMBRO and their commitment to their environmentally focused manufacturing practices. Adafruit knows you have a lot of choices as to where you spend your money and time, we hope our open-source values, commitment to green technologies and partners helps make the decision easier and fun!
[Here is] My daughter, who is 4.5 years old, wanted to read from the coloring book as a way to say thank you! You may not always know it but this sort of thing will stay with her forever. Thank you!
Turn up the volume, it’s not only super-cute, it’s the future, it’s inspiring.
Ladyada’s “E is for Electronics” is a coloring book adventure with electronic components and their inventors.
Makers of all ages can learn, color, and share common parts and historical figures throughout history. Explore the world of electronics with Ladyada as your guide!
Here’s an excerpt:
“A diode lets electrons flow in only one direction. It works like a switch: when current is flowing one way, the switch is on, but when current tries to flow the other way, the switch turns off. Sir John Ambrose Fleming is best known for inventing the diode, originally called the kenotron.”
Coloring book dimensions: 8.5in x 5.5in
MADE IN THE USA!
This is the first ever open-source electronics coloring book! Adafruit’s coloring books are manufactured in the USA by a family owned and operated business, we use non-toxic soy based, water soluble and environmentally friendly printing supplies. The equipment used is solar powered! Adafruit knows you have a lot of choices as to where you spend your money and time, we hope our open-source values, commitment to green technologies and partners in the USA helps make the decision easier and fun! Crayons not included.
Support these young women who are New York City’s future entrepreneurs and engineers as they unveil the apps built during the Girls Who Code program. The evening begins with the Social Investor Presentation where the Girls take over the NYSE Boardroom to pitch their creative technology and ability to change the future. The pitches are followed by a networking reception and demos on the NYSE Trading Floor.
Monday, October 22, 2012 New York Stock Exchange
5 – 6:30 pm Investor Presentation by the Girls in the Board Room
Jack Dorsey, Founder, Twitter, Square Arianna Huffington, Huffington Post Chris Hughes, Co-founder, Facebook Beth Comstock, CMO, General Electric Marisa Ricciardi, SVP Global Marketing, NYSE Euronext Alexis Maybank, Founder, Gilt Groupe Gina Bianchini, Founder, Ning, Mightybell Craig Newmark, Founder, Craigslist Hope Taitz, Apollo Residential Mortgage Inc David Hirsch, Metamorphic Ventures Sunny Bates, Sunny Bates Associates Andrew Rasiej, Personal Democracy Media Kelly Hoey, Founder, Women Innovate Mobile Greg Gunn, Founder, City Light Capital Rachel Haot (Sterne), Chief Digital Officer, NYC Nihal Mehta, Founder, Local Response Steve Martocci, Founder, GroupMe Caroline Ghosn & Amanda Pouchot, Founders, LevoLeague Rachel Sklar, Founder, Change the Ratio
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.
From Liz’s note at Raspberry Pi during the lead up to the event:
Eben’s giving a talk at the Institution of Engineering and Technology’s Young Professionals event this evening. One of the subjects he’ll be talking about is open hardware, which I know a lot of you are interested in – I hope you can find some time to watch!
I’m off to watch Twitter like a hawk. James May from Top Gear has just been tweeting about his Raspberry Pi this morning, which has had us punching the air in a masculine fashion. Unfortunately, he has hit a small initial bump in the road. In cases like this, we strongly recommend stealing borrowing the SD card from your spouse or child’s camera.
After months of efforts to bring this about, we are thrilled to be participating in what we believe is an important New York City initiative.
Here’s a quick highlight about Adafruit’s involvement in the project:
“Adafruit has thrived in New York City as an electronics manufacturer and educational company,” Limor Fried, Founder and Engineer, Adafruit Industries. “The old saying goes if you can make it here, you can make it anywhere – but there isn’t any other city in the world we could have grown and built our company. I’m looking forward to working with the next generation of makers, business leaders and New Yorkers who want to make the next big thing in New York City!”
At the core of the initiative is the launch of the competition New York’s Next Top Makers. This competition “will act as a business accelerator for New York City-based entrepreneurs, inventors and makers, who will be judged by a panel of experts as well as the public and will receive assistance on the path to commercialization, including studio space, business support and mentorship from industry experts including Shapeways, Adafruit Industries, and Honeybee Robotics.”
We wanted to make sure to share the news as soon as it became official — so we are including the entire copy of the press release below the fold.
Following discussions about the Open Source and Open Source Hardware logos, the Open Source Initiative (OSI) and the Open Source Hardware Association (OSHWA) have worked together to compose a co-existence agreement on behalf of their representative communities.
We are pleased to announce that the co-existence agreement has now been approved and signed by both organizations. This agreement means that each group separately has control of their respective logo and in particular that the Open Source Hardware community will be able to continue to use the Open Source Hardware logo.
As per the agreement, OSHWA will (in the near future) publish guidelines for the use of the OSHW logo, designed to promote its use in compliance with the Open Source Hardware Definition. Until then, if you are using the OSWH logo, please make sure that you are following the OSHW definition. And, to use the OSI logo, please refer to OSI’s trademark usage guidelines.
Working with other organizations is just one of the ways we serve the community. Through your membership support, both OSHWA (join now!) and OSI (join now!) hope to continue representing your needs.
So, anyone putting the OSHW logo on your boards, you’ve always been fine, you are fine and you always will be fine
This is the outcome we asked as OSHW makers for from the start and it’s great to see this happening and official two open source orgs working together for the benefit of all. For the folks following this story, last year Phil ask the previous OSI board if the gear logo was ok after there were questions if it was too close to the OSI logo (Phil contacted the previous OSI members and they said it was fine) but this year with a new OSI board this process re-started. In a fun twist, the OSI logo appears to be Phil’s logo he debuted at OSCON about 10 years ago. Below…
Printable catalog (PDF)
)
I’m 
Why were these designs so different? Well, we did look at doing a “cost down” on the first-generation design. Every part of it was too expensive. In so many kinds of engineering, scale ripples out. If you build a bridge with a really heavy surface, the supports for that surface have to be heavier too, and so on.
This was quite a challenge: creating fluid 2D graphics on a chip designed to run wireless mice and keyboards, a peer of the original Arduino. No separate graphics chip, no custom-designed silicon. Just software and some very simple hardware. To make this possible, I took inspiration from the 1990s.
FEED
