GPS trackers are always interesting because they’re so versatile. Location-based services have exploded in the last couple of years, and are poised for more growth as we get further into the 2010′s. At the heart of all of these services is a GPS tracker, and a method of transmitting position data to a server, where a provider (or hacker) can do something useful with it.

In the same vein as the previous open source tracker from DSS Circuits (which seems to have shipped and posted source code on GitHub, hurray for successful Kickstarter projects), there is a new kid on the block looking to create an entire open source tracking platform.

The i.AM (Intelligent Asset Management) GPS tracking system from WRD Systems is also looking for some crowdfunding love. It includes plans for an open source tracking device, a desktop application and mobile apps to aggregate and organize tracker data. The company needs a healthy chunk of change to finish hardware and software development, plus do an initial production run.

The hardware looks small and clean, with an integrated GSM/GPS module and not a lot of extraneous components. It’s powered by an ATTiny 2313 and a SIMCOM SIM908C for tracking and transmitting. The software we have some questions about – why make a desktop app when you could accomplish the same thing with a web service? Hosting costs wouldn’t be too high, and it’s much more accessible, easier to integrate the data with other applications, or incorporate community improvements. Desktop just feels rather… 2004-ish. Also, while not unique to this project, we’d like to see these creators open up more of their development before the project gets made. It’s always difficult to show off a work in progress, but by taking feedback early and often, the end result is a product that is more aligned with users’ needs and wants.

The team and project seem to have a solid technical foundation, so it’s reasonable to assume that the core rewards will get filled. Interestingly, the Kickstarter page mentions collaboration with other makers of OSS trackers, including the DSS product. A unified platform for all manner of tracking devices would be a very interesting play, something a la Electric Imp or Cosm for the GPS world. Again, that would seem to necessitate a web platform, but we’ll be watching to see how this one turns out.

The Raspberry-Pi has been a media darling as of late, and deservedly so. It’s a full computing platform that can do many wonderful things, all for less than a few day’s worth of Starbucks lattes. But what if you simply need moah powah?

In that case, you need the ODROID-U2 from Hardkernel. How does a 1.7Ghz quad-core strike you? 2GB of RAM, perhaps? With 10/100 ethernet, 2 USB ports, and micro HDMI, ll for less than $90? I can feel your burning stare of disbelief. Go ahead, check out the link for yourself. I’ll wait.

Aha, so you’ve seen it with your own eyes. Now that stare has turned into a soft mad-scientist chuckle, eh? It’s ok, we had the same reaction ourselves. ODROID is short for “Open Android”, and apparently Hardkernel has developed an entire ODROID product line in the past. Previous models have advertised development applications from e-book readers to internet TV.

The U2 runs either Android 4 or Ubuntu Linux (and perhaps other Linux flavors as well, though we’re not sure). It features a Samsung Exynos 4412 Prime SoC, which includes an ARM Cortex-A9 as the central processor. Unlike the Pi, you’ll need some accessories to get it running out of the box, as you must power it with an external adapter and not via USB.

Since the Raspberry-Pi is reportedly a little sluggish for media-intense applications, it would be interesting to see how this little bugger performs as a media center or car-PC. Either way, low cost hardware like the ODROID is a huge win for the hacking community, and we can’t wait to see what comes down the pipeline next.

In our previous Atmel tutorial, we talked about how to set up the powerful AVR Studio 5 IDE to incorporate Arduino libraries and projects. As flexible as AVR Studio 5 is, it had a few issues, and Atmel has been hard at work hustling the next major version out the door. Now, rebranded as Atmel Studio 6 (no longer just for AVRs!), the new version promises to be better, faster, and easier to use. Here, we’ll show you the quickest way to get up and running if you want to use Arduino code with all of the new features.

Note: This article explains how to set up the Atmel Studio 6 IDE for use with Arduino projects, step-by-step.  It also notes on general setup for working with Atmel devices, background on the pros/cons of working with AVR Studio, and a few other tips.  A table of contents is below; feel free to skip to any section that interests you.

• Introduction
• Preparing AVR Studio and the Arduino core library
• Compiler and linker setup
• Build your project
• Flash!
• Final notes
• Further reading

Introduction

Atmel Studio 6 delivers a lot of the value that AVR Studio 5 promised but never quite gave.  Released in 2011 and based on Microsoft Visual Studio, Studio 5 was a large change from AVR Studio 4, which was based on the tried and true Eclipse IDE.  Studio 4 is seriously showing its age these days, so a refresh was welcome. However, version 5 came with a long list of bugs and didn’t deliver on a lot of the feature list, which left a lot of people wondering whether they should upgrade. The new version appears to have addressed a lot of those bugs, and gets higher marks from us in our initial testing.

Why should I switch?

Atmel Studio is a great choice for users that have outgrown the integrated Arduino IDE.  The Arduino IDE does so much under the hood that it can actually be quite limiting for experienced programmers.  As we discussed in our previous tutorial, the lack of compiler warnings and debugging capabilities (Serial.println() after every statement doesn’t count), make life hard when working on advanced projects.

AVR Studio is a huge step up from those limitations, but for many, making the switch cold turkey is just that: a huge step.  If you have a big project, porting the entire thing to pure C can be a daunting task.  Plus, some of those Arduino libraries are just so darn convenient. Software serial, anyone?  Ethernet capability?  Aw yeah.

So why not have the best of both worlds?  Arduino is basically a wrapper on top of C/C++ anyway, so technically, it’s possible to combine any Arduino sketch or library with your own custom code.  The trick is in setting up your project properly.  Here are the steps to create a fully functional Arduino project in AVR Studio 6.  Once accomplished, you can keep access to the huge Arduino user-contributed code library, but enjoy all the features of advanced AVR and a real IDE.

Preparing AVR Studio and the Arduino core library

1. First, a few preparation steps.  This tutorial assumes you have AVR Studio installed already.  Unlike the last version, Studio 6 comes with full C++ support out of the box, so we don’t need to install anything extra.
2. In order to build Arduino projects, we need to grab the Arduino core library. Normally, the Arduino IDE compiles this for us whenever we compile a sketch. To use it in Atmel Studio, we’ll compile it first, then grab the compiled version and include it in our project. Open the Arduino IDE and turn on verbose output (“File” -> “Preferences” -> check “Show verbose output during compilation”). On Windows Vista or 7, the path should look like this:  C:/Users/<MyUser>/AppData/Local/Temp/
3. Make sure the Arduino IDE is set for whichever chip you want to use with Atmel Studio, and compile any example sketch, such as the included blink example. In your output window at the bottom of the IDE window, you should see information on where the IDE put the temporary build output. It will look something like “C:Users\{Your User}\AppData\Local\Temp\build3173545040878149377.tmp”.
4. Before you open it, go to your Atmel Studio working directory. This is the folder that stores all of your projects – by default, it’s “..\My Documents\Atmel Studio\”. Create a new directory here to store your Arduino core files, and name it something appropriate (“arduinoCore” or similar).
5. Copy and paste the temporary directory from the Arduino IDE into Windows Explorer to open it. You’ll see a bunch of files, including one called core.a. Copy that file and paste it into your arduinoCore directory. Rename it from “core.a” to “libcore.a” so Atmel Studio recognizes it as a standard library. Now that it’s there, you can reuse it for any Atmel Studio project as long as you’re using the same type of AVR.
6. If you’re converting an existing sketch called <sketch name>, open the <project_name>.cpp file from the bldxxx.tmp directory in a text editor.  You can simply copy and paste this code into your AVR Studio project to speed things up in a minute.
7. Sweet, we’re ready to switch environments.  Open AVR Studio and create a new AVR Studio C++ executable project.  Remember to name it in the wizard that pops up, because it’s a pain to rename a project later.
8. Choose your chip type. Many Arduino boards use the ATMega328 or 328P, which you’ll find under the megaAVR, 8-bit device family. Older Arduinos use the ATMega168, while the newer Leonardo uses the ATMega32U4. Look closely at the chip on your board for the model # if you’re unsure what chip you have.
9. Copy and paste the source code from the compiled .cpp file you opened earlier into the project’s main .cpp file.  You can also copy/paste the source from your Arduino .pde sketch.  The first option is easier because it includes necessary function prototypes that the Arduino IDE automatically generates, while in the latter case you must add them yourself.  In either case, you have to have these prototypes, or else the compiler will complain that every single function is “not declared in this scope” when you try to build your project.  This is one of those things that the Arduino IDE hides from you.  Adding your own prototypes is a no brainer once you’re used to it, and it can actually save headache because automatic generation can cause problems in more advanced projects. Remember to include prototypes for setup() and loop() – those aren’t default CPP functions, and the AVR compiler sees them as your own additions just like anything else.
10. Add #include Arduino.h". to the very beginning of your source code.

Compiler and linker setup

1. Now we have to tackle proper compiler setup and linking.  Go to “Project”->”<ProjectName> Properties” (or press Alt-F7), then click on “Toolchain”.  We need to setup a bunch of compiler options here. By default, this will only edit your “Debug” build configuration, so select “All Configurations” from the Configuration drop-down menu if you want to modify both release and debug configurations at the same time.
2. First, click on “Symbols”, in the left-hand “AVR/GNU C++ Compiler” dropdown menu. We need to add a symbol to tell the compiler the speed of our chip: for example, click the green plus icon, then enter "F_CPU=16000000L" for a 16Mhz chip. Most 5V Arduinos are running at 16Mhz, hence 16000000 (L stands for long integer). If you have a 3.3V Arduino, it will likely be set at 8Mhz, so use F_CPU=8000000L instead. Next, add another symbol to define your Arduino software version: "ARDUINO=100" for v1.0, "ARDUINO=101" for v1.01, etc.
3. Click on to “Directories” in the same C++ Compiler menu. We need to add the directories that contain our Arduino core code and libraries, so the compiler can string it all together for us. For any Arduino project, we’ll need to tell the compiler where to find “Arduino.h” and “pins_arduino.h”. Starting in your Arduino installation directory, add the folders “./hardware/arduino/cores/arduino” and “./hardware/arduino/variants/standard”.
4. You’ll need to add the directories of any extra Arduino libraries you’re using. For example, if you include the SoftwareSerial library, go ahead and add that directory to this section so the compiler knows where to find it. If you forget anything, the compiler will tell you when you try to build, with a message such as “SoftwareSerial.h: No such file or directory”. You should also add the home directory of your project, so the compiler can find source files there.
5. You’ll also need to add the .cpp source files for those same linked libraries to your actual Atmel Studio project. Add a directory to your project (“Project”->”New Folder”) and name it “libraries”, to keep things organized. Then, go to “Project”->”Add Existing Item” (or Shift+Alt+A), and find the source directories for your included libraries (usually in “/libraries”, unless you have a custom setup). Select the source files, but instead of clicking the “Add” button, click the small arrow next to it, and click “Add as link”. You’ll notice the file show up in your Solution Explorer with a small shortcut icon next to it.



6. Click on “Optimization” immediately under “Directories”.  Choose “Optimize for size” under “Optimization Level“.  Add "-fdata-sections" under “other optimization flags”, and check the box for “prepare functions for garbage collection”.  Next, click on “Miscellaneous” in the same list, and add "-fno-exceptions" to the “Other flags” field.  Keep in mind that the Arduino IDE keeps all other optimization flags off – feel free to leave the other default boxes in “Optimization” checked as they may improve program size, but if you’re having build problems, try turning them off.
7. Now we’ll move on to the linker. In the left-hand menu, click on “AVR/GNU Linker”->”Libraries”. In the top Libraries section, you should already see an entry for “m”, which is the AVR math library. Add an entry called “core”, which is our libcore.a file that we grabbed earlier.
8. We also need to tell it where to find libcore.a, so add our earlier “arduinoCore” directory under “Library search path“.
9. Click on “AVR/GNU C++ Linker”->“Optimization”, and check the box for  “Garbage Collect unused sections (-Wl, –gc-sections)”.  This tells the linker to leave out unused portions of each library, which reduces final code size.
10. Awesome, we’re done with the project setup. Save your settings, and we can get back to the code.

Build your project

1. At this point, your environment should be completely set up.  Hit F7 to build your solution and watch the output window.  Is it successful?  If so, great.  If not, take a look at the errors to see if there’s a problem with the code or if it’s likely a problem with the linked files.  Also take a look at the beautiful new world of compiler warnings you’ve uncovered.  If your project is at all complex and you’ve only compiled using the Arduino IDE previously, you’ll have at least a few warnings.  These warnings won’t necessarily break your program, but they could.  Eliminating them usually means you’re following best practices.  There are a few warnings generated by the Arduino core libraries – if you’re feeling adventurous you can alter that code, but everything will work fine if you leave them alone.

Configure AVRDude to flash your compiled code

1. Once you’ve built your project successfully, you need to upload it to your device.  Fortunately, you can do this using the exact same method as the Arduino IDE.  Arduino uses the avrdude utility to flash via serial, and we’ll do the same.  We just need to tell AVR Studio what options to use.  Click on “Tools”->”External Tools…”, then click “Add” in the window that pops up.
2. If you’re using a USB to Serial cable like most Arduino boards do, note which COM port it uses and make the title something like “Usb to Serial Programmer: COM10″ for easy identification.
3. In the “Command” field, put the path to avrdude.exe in your Arduino installation.  For example: "C:/arduino-1.0.1/hardware/tools/avr/bin/avrdude.exe" (quotes removed).
4. In “Arguments”, paste this line: -CC:\dev\arduino-1.0.1\hardware/tools/avr/etc/avrdude.conf -v -v -patmega328p -carduino -P\\.\COM10 -b57600 -D -Uflash:w:"$(ProjectDir)Debug\$(ItemFileName).hex":i   Edit the path to your Arduino installation and change the COM port, chip target, and baud rate if necessary (ATMega328′s normally need 57600 baud, older ATMega168′s flash at 19200. One of our commenters pointed out that the Arduino Ethernet uses 115200 by default, so check what the Arduino IDE is using and copy that for your model).  The rest of the flags are the exact same as the Arduino IDE uses.  The “-v” flags control the level of verbosity – feel free to play with this parameter.  You can include up to four “-v”s (which logs every serial byte transmitted, woohoo!), but we’ve found that two flags provide enough information without being overwhelming.  Note: if you have any trouble with this step, go back to the Arduino IDE and flash a project in verbose mode by holding Shift while you press the “Upload” button.  This will display all of the command line output in the bottom status window, and you can see exactly what command your system is using to call avrdude.exe.  Edit accordingly for the AVR Studio options.  You may also want to check the “Use Output window” box so you can see the results of the flash; otherwise AVRDude will open a command window and close it the moment it’s done.

Flash!

1. Boo yah.  Go back to your project and click on the “Tools” menu; there should now be a new menu item for your “USB to Serial Programmer”.  Make sure you have the main .cpp source file open in your IDE window – the serial programmer will try to access a .hex file for whatever tab is open, so this is the only one that will work. Ensure your Arduino is connected to your computer, then click the Programmer menu item.  You should see AVRDude open up in your output window, then a progress bar showing flash status.  Look for the “AVRDude is done.  Thank you!” message after a successful flash.

A lot of this prep work only needs to be done once.  You’ll need to set up the toolchain properly for each project you create, but now that you have the Arduino core library and some practice, things go much quicker the 2nd time.  The AVRDude setup is universal and can be reused for every project.

You’re done!  You now have an Arduino with a fully working project, and a huge amount of new development possibilities ahead of you.  Explore AVR Studio and everything it has to offer, you’ll be impressed.  The AVR Simulator and step-through debugging are absolutely priceless when you’re working on a complex project, and you can now mix Arduino and avr-libc code to your hearts content.

Final Notes:

1. In some cases, your build may produce ‘cxa_pure_virtual()’ errors.  This is due to a missing error handling function for pure virtuals in C++, but we can provide it ourselves:  add

   extern "C" void __cxa_pure_virtual() { while (1); }

   to your main source file.  This function doesn’t do much, but from what we’ve read these errors can safely be ignored, so we just provide a dummy function to make the compiler happy.  You could also place this in a "pure_virtual.cpp" file and then include it in every new project.

2. Are you looking for a cross platform solution?  You won’t find it here, as AVR Studio is Windows only.  If that’s alright with you, full steam ahead, but otherwise, you may want to look at Eclipse as a full-featured, cross-platform IDE.  AVR Studio has some features that Eclipse doesn’t (the AVR Simulator is huge, among other things), but the latter is no slouch.  The Eclipse setup process is similar and is outlined in great detail on the Arduino website.

Further reading

Smiley’s Workshop, a site dedicated to AVR programming and projects, has a comprehensive article on switching from the Arduino IDE to AVR Studio.  It’s a bit older and discusses AVR Studio 4 instead of 5, but is excellent background reading if you’re still trying to wrap your head around everything.

Following up on our previous post on understanding floating point math and speed of operations on 8-bit AVRs, we ran across an excellent article today on Arduino math optimization. Alan walks through his implementation of an exponential moving average algorithm. An exponential moving average normally requires floating point arithmetic, but due to the lack of native support on 8-bit AVRs, Alan worked out a way to do it with fixed point math.

After some experimentation, he was able to get his version running quite a bit faster than the floating point version, and offers a detailed writeup and tips along the way. Just as we found in our brief testing, the easiest AVR math optimization is to avoid division, since these processors don’t have a native divide instruction. If you’re looking to squeeze every last drop of performance out of your 8-bit chip and can’t (or won’t) upgrade to something more powerful, check this out for some good ideas.

Link: Sensor smoothing and optimised maths on the arduino

Original source: Hackaday

A post on Embedded Lab that discusses using a CMOS camera for sensing applications caught our eye today. Traditionally, to process the output from a CMOS you need some serious number-crunching power, and common lore holds that most 8-bit microcontrollers aren’t up to the task. However, Ibrahim Kamal from IKALOGIC has written an article that explains how you can use a CMOS to replace rudimentary image or light sensors such as photo diodes.

By reducing the captured resolution, discarding color data, and potentially converting the pixel values to binary information, you can still receive useful input but can parse it with a low-cost, low-power processor. In this way, an 8-bit chip can open the door to basic image processing, allowing for lots of possibilities in robotics or other projects.

The article includes an example that hooks up a CMOS available on Sparkfun (the TCM8230MD) to an AVR XMega. For $10, you have no excuse not to try it in your next sensing project.

Article: IKALOGIC
Source: Embedded Lab
Image: Sparkfun

Sitting in between these two worlds and bridging the divide is electronics. Without it, there would be no microprocessors, no grids of tiny transistors to switch on and off and do our bidding millions of times per second. No way to power our homes or gadgets, or even manufacture many of the non-technical goods we take for granted. It has truly revolutionized every facet of our existence. Much emphasis today is placed on programming and application development, but it is important to remember that these things are abstractions sitting on top of a physical and electrical foundation.

In case all of this talk of revolution has you fired up, we’ve collected some of the best books to help you learn electronics. Whether you’re a total beginner or advanced engineer, check out the resources below to find a learning guide that’s right for you.

The Art of Electronics

Paul Horowitz, Winfield Hill

In many fields of study, there is often a “grand-daddy” or “godfather” textbook. This is the book that is passed down from generation to generation, the reference that graces every introductory college course on the subject. Some might even call this book the Bible of it’s respective topic. The Art of Electronics, published in various forms for over 30 years, is that book for electronics.

We would write a mini-review of this book as we do for the others, but its history speaks for itself. If in doubt, check the reviews on its Amazon page, both from various published sources and Amazon buyers. When words like “delightful”, “lovely”, “refreshingly simple”, and “finest book on the subject of electronics” are thrown around with reckless abandon, you know you’re dealing with a trusted source.

We should note here that The Art of Electronics is not a quick read, as it clocks in at over 1100 pages. However, it’s designed as both a learning resource and a reference, so you can easily keep it handy and look up a particular topic or concept as needed. It’s also a bit more expensive than other books here, but most agree the price is well worth it. If we had to pick one book on electronics to keep on our shelves, this would be it.

Get it here: The Art of Electronics

Getting Started in Electronics

Forest M. Mims III

Despite the name of another classic book on this list, Getting Started in Electronics is truly about the art of electronics, and is a work of art unto itself. Each page is hand lettered and each illustration is hand drawn, lending it the comfortable feel of a class notebook. The painstaking effort is clear in every facet. In the author’s own words:

The book was developed during a 58-day marathon session of laying out the book and then drawing/printing the pages with a 0.7 mm mechanical pencil. It was then necessary to develop and test each of the 100 circuits. Each circuit was built and tested at least three times to avoid errors. The final round of tests was done directly from the hand-lettered text. The problem with the final testing was that many of the circuits could be built from memory without referring to the circuit diagrams in the book. This, of course, could have allowed errors to slip through. So it was necessary to check off each connection to make sure the book version was correctly reassembled from scratch.

Mim’s personal touch continues throughout the text, and readers unanimously agree that the book is friendly to beginners, easy to follow, and provides a ton of good examples. Electronics is never an easy subject to master, but if you are a total beginner, this book is a good place to start.

Get the book here: Getting Started in Electronics

Make: Electronics (Learning by Discovery)

Charles Platt

Charles Platt is a contributing editor to Make: Magazine and has a long history in electronal hardware and technical writing. This book emphasizes hands-on learning. The experiments begin as soon as you crack open the first chapter (with a battery to the tongue, no less) and continue throughout, with little time wasted explaining historical background. If you are someone that needs to learn by doing, Make: Electronics is the perfect companion. Although the book does go deeper into theory as you progress, it eases you into it, and chooses the appropriate time to introduce more complex concepts. In the words of one reviewer:

I learned more in the first 20 minutes with this book than I did after pouring through several other “electronics basics” books for countless hours.

Overall, this is a great introduction to electronics and highly recommended for anyone who wants to get their hands dirty right away.

Find the book here: Make: Electronics (Learning by Discovery)

How to Diagnose and Fix Everything Electronic

Michael Geier

This guide is the appropriate choice for anyone who absolutely hates textbooks. Written from an entirely practical perspective, How to Diagnose and Fix Everything Electronic discusses relevant skills for working with electronics in the real world.

Though you might not gain the same deep understanding as you might from one of the more theoretical texts above, the topics conveyed are extremely valuable. Michael Gaier covers tool selection and workbench setup, how to disassemble and examine various devices, and how to successfully replace components and button everything up. The tips on workflow with actual devices is especially valuable, as most electronics books cover circuits from an abstract, laboratory-oriented perspective.

Snag the book here: How to Diagnose and Fix Everything Electronic

When you learn the basics of the electrical world, you begin to understand how our advanced technology is shaped. When your phone battery runs low, you understand what’s going on. If your camera breaks, you may know enough to attempt a repair, saving you money. Even knowing the basics of voltage, current, and power can help you analyze your energy usage and save money on your next electricity bill. Finally, you have the power to create and modify your own devices, instead of forever wondering how that magical little iPhone does it’s thing.

Pick up one of these books and start learning. No matter what your skill level, you’re bound to find a wealth of fascinating insight and possibilities for exploration.

Do you have suggestions for other books to check out? Let us know in the comments. Until then, enjoy discovering the limitless possibilities of electronics.

Image credit: aresauburn

Click any item on the list to jump to the relevant section:

1. Open Energy Monitor – Build a home energy monitoring system
2. OpenMoCo – Make automated camera control rigs like the pros
3. DIY Drones – Fly an unmanned aerial vehicle
4. DIY Magic Mirror – Create a cinema-worthy prop
5. Arduino beer brewing – Get yo’ geeky drink on

Open Energy Monitor

Open Energy Monitor is an open source energy monitor for use throughout your entire house.  Much more than just a quick circuit you slap on your utility meter, OpenEnergyMonitor consists of multiple components that work together to take readings on energy consumption by room or device, room temperature, and more, then feed all of it wirelessly back to a dashboard that can be displayed locally or through a web interface.

We like Open Energy Monitor a lot because it’s a great introduction to real-world systems. When you build a home monitoring or automation platform, you’re using your Arduino as part of a larger network rather than just a standalone device.  Learning how to get your microcontroller talking to the outside world is critical as you graduate to more complex projects, and OEM provides a great example of a polished, well designed architecture.

OpenMoCo – The Open-Source Photographic Motion-Control Community

As described in the expanded title, OpenMoCo is all about enabling motion in photography. Whether shooting video, time-lapse, or panoramic photography, accurate camera motion is often an important consideration. As many photographers know, professional equipment for automating camera movement and activation can be prohibitively expensive. OpenMoCo serves as a repository for community knowledge on how to design and create motion control tools on a budget.

Most OpenMoCo tools start with the OpenMoCo reference design, which is a modular platform that consists of an engine, interfaces, and elements. The Arduino-based engine covers the brains of the operations, interfaces include various UX controls and displays, and elements comprise motion tools such as stepper motors or actuators.

DIY Drones

Have you ever seen Predator drones in the news or watched the robot planes in Terminator movies and thought “Man, I wish I could build one of those”? Well, now you can. DIY Drones describes themselves as “the home for everything about amateur Unmanned Aerial Vehicles (UAVs)”. We don’t think too many people would argue, as the community has grown to over 20,000 members and is one of the top 100,000 websites in the world.

DIY Drones goal is to create hardware and software for any type of aerial robot, whether it be a helicopter, plane, quadcopter, or blimp. Their site is packed with various user groups, blogs, and forums, all with useful information on starting your own project. The DIY Drones store offers their premier product, the ArduPilot, a universal autopilot board equipped with an Arduino Mega 2560, 6-axis gyro/accelerometer, and GPS. Depending on what type of vehicle you’re creating, you can flash appropriate software such as ArduPlane or ArduCopter and be completely ready to fly. If you’re interested in drones or even radio controlled aircraft of any type, check out the site, because there’s a wealth of useful experience for any level of hobbyist.

DIY Magic Mirror

The DIY Magic Mirror is nifty contraption that will turn heads at your Halloween party, theme house, or even a bar. By combining an Arduino-compatible sensor kit with a laptop display and open-source software, you can create a mirror that interacts with visitors and spits out custom messages with text-to-speech. The site is more of a business venture than some of the other communities here, but the code is out there and the prices for the hardware are reasonable. You can get as involved as you want, by building the kit from scratch and even adding a breathalyzer so your mirror can publicly shame friends that overindulge at your holiday party.

Arduino beer brewing

Home brewing has gotten increasingly popular recently, as breweries get smaller, equipment gets cheaper, and Portland hipsters get more discerning in their IPA preferences. Luckily, Arduino can make this process easy, and a number of enterprising hackers have posted information on their automated beer brewing journeys.

The best resource we know of for this type of project is the HackaDay beer hacks category, which has plentiful examples of homemade mashtuns, kegerators, and automated dispensers, all enhanced with Arduino.

There are also several other noteworthy destinations for Arduino-powered beer projects. First up, Kegbot is an impressive and full featured beer tracking and pouring system. As described on their site:

Kegbot is a free, open-source project to turn your beer kegerator into a computerized drink tracker. Kegbot is an open source project, intended to beer enthusiasts, DIY hackers, homebrewers, and anyone with an interest in monitoring their beer.

Next, homebrewing.com has an article on home brewing automation with Arduino, which links to several other projects such as the Halfluck Automated Brewing System (HABS) grain brewing machine.

Wrap up

There’s enough here to keep you tinkering for a while, but we know we’ve only scratched the surface of great high-level Arduino projects. Do you have any suggestions that we should add to this list? Let us know in the comments. In the meantime, happy hacking…

A new Kickstarter project aims to provide a low-cost, open source platform for building a GPS tracking device. The author, Wayne Truchsess of DSS Circuits, explains that a few years back, his brother in law had a PS3 stolen during a long power outage in the depths of winter. Not wanting to repeat history, Wayne bought a fake PS3 case on eBay and developed his own prototype position tracker to put inside it.

The tracker consists of a GSM cellular modem, a GPS unit, and an accelerometer, all tied to an Arduino and a LiPo battery to provide brains and power, respectively. Normally, the device lies in wait, asleep to save power. If it detects motion, it turns on the modem and alerts a preconfigured phone number via SMS. The owner can then respond with various commands to turn position tracking on or put the device back to sleep.

The prototype worked well, but used a lot of different components that were only loosely tied together. This made it difficult for Wayne to tell others how to replicate the project, and also took up a lot of room inside the case. After getting a lot of interest in the project, he decided to condense everything down to one board, and thus this Kickstarter project was born.

If funding goals are met (as of this writing there is 52 days and less than $500 to go), Wayne will complete the project and open source the code, schematics, and board design. He is offering the bare bones populated board at the $126 backing level, so as long as he isn’t relying too heavily on volume discounts, it seems likely that others could make their own device around that price point.

As the project writeup mentions, a theft tracking device is just one great idea that this platform enables. GPS, cellular, and motion detection is a powerful sensing combination, and there’s really no limit to the projects that could be devised using the same package.

If you like the project, check out the Kickstarter page and consider donating so Wayne can bring some Arduino tracker goodness to the masses. Do you have your own idea for a Kickstarter project? Let us know!

Soldering is a skill that electronics newbies often find intimidating, but it doesn’t have to be. Jeff Keyzer, Mitch Altman, and Andy Nordgren put together an excellent guide called Soldering is Easy. It’s packed with information on how to make good solder joints. Better yet, it’s illustrated in comic book format, so every explanation comes with clear pictures on exactly how to do things.

If you’re new to electronics and circuits, check out the guide to get up and running in no time. Even if you’re experienced but feel like you could shake off some rust, give it a glance. Good soldering technique is a lifelong skill that saves time and energy by creating cleaner, more reliable projects.

Source: MightyOhm via Tinkerlog

In a previous post, we covered online IDEs for embedded software development. In order to run embedded programs you need to, well, embed them in something, so we also included a paragraph on Upverter, a tool for collaboratively editing and sharing circuit schematics.  Hardware design is an area that’s still relatively untouched by the web application revolution, and we always love to see new innovation.

More recently, we ran across CircuitLab, an alternative schematic tool with some unique features. On the surface, the site seems extremely similar to Upverter: fire up an online editor, create your circuit in the browser, then save it to your account. At any point in this process, you can share a link to your circuit to let others view it and collaborate.

There are a few key differences with CircuitLab when compared to its YC-backed brethren. While Upverter aims to be a GitHub for hardware, with full permissions, multiple user editing, and version control, CircuitLab’s sharing is less nuanced. You can share a link to your schematic so that others can view it and leave notes, but multiple users can’t edit the same project. If they save your circuit, CircuitLab will save a separate copy to their account (a bit like forking using version control, but without any advantages of being able to merge changes later).

CircuitLab’s killer app is the fact that it allows real-time circuit simulation using models similar to SPICE, a popular desktop simulation package. Testing your circuits as you create them is a huge advantage, and if there’s any other online tool that allows this, we’re unaware of it.

Finally, CircuitLab is completely free for the time being, another differentiator from Upverter. The site points out that it may charge for premium features in the future, but for now, it’s all you can eat.

If someone could integrate PCB layout into one of these sites and construct a full EDA suite in the cloud, they would create serious business value.  The fact that Eagle, a 20 year old program that looks every bit its age, still dominates the hobbyist and small business market means that this niche is ripe for disruption.  Entrants like CircuitLab are a step in the right direction, and it will be interesting to watch how they evolve in the coming months.

If you’ve used CircuitLab before, let us know in the comments, and if not, check them out and tell us what you think.