text:
Project Showcase '14

The logo is a derivative of the Arduino Community Logo licensed under Creative Commons license CC-SA-BY-NC 3.0

Update: Winners Announced
The winners of the contest have been announced. Please see the Meta post for details.
To celebrate 10 years of Arduino, we are proud to announce the first event ever on Arduino Stack Exchange.

Get your boards and soldering equipment out, dig out the ICs and
  resistors. The first Arduino Stack Exchange contest is just round the
  corner. We will be looking for interesting projects that are built
  using Arduinos. The contest is aimed towards sharing, discussing and
  providing feedback on projects that you and other members are working
  on. See announcement post

Details:

The prize is an official Stack Exchange t-shirt
Limit two entries per person. If more than two are provided, only the first two will be considered.
Clones are allowed.
Projects for consideration will be accepted through March 29th, 2014 at 4:00 UTC. The question will still remain open in case someone wants to show off their project they made on Arduino Day 2014.

Visit the Meta post for discussion about this event and further information.
Answer Format
You may post up to two projects (as two separate answers) as entries for the contest. All extra entries will be deleted. Consider following the following template for entries:

Project Title
Very Brief Description
Description
What is your project? What does it do? What problem does it solve?
Design
Things to include in this section:

Schematics and other design documentation. Fritzing is a good tool for drawing breadboard schematics like the one shown in the
  project logo above.
Components used to build the project
Pictures or video

Conclusion
Final thoughts. What did you learn from doing this project? What would
  you do differently if you had to start over?

You can copy/paste the following text if you want to use this template.
# Project Title
**Very Brief Description**

# Description
What is your project? What does it do? What problem does it solve?

# Design
Things to include in this section:

- Schematics and other design documentation. [Fritzing][8] is a good tool for drawing breadboard schematics like the one shown in the project logo above.
- Components used to build the project
- Pictures or video

# Conclusion
Final thoughts. What did you learn from doing this project? What would you do differently if you had to start over?

Prizes
There are two prizes! The winner will be the submission getting the maximum number of upvotes (downvotes do not count) and will get a Stack Exchange T-shirt*! There will be something for the runner-up as well. The runner-up will be decided at the discretion of the event organizers.
*Certain restrictions may apply. International shipping may take a few weeks.
Where do I submit my projects?
Post your projects as answers to this post.

What exactly is the qualification for being an "arduino" project? I use optiboot in lots of places, but I can't see that as being "arduino", since it's just a project that the arduino toolchain uses. Short of using a board in the arduino-form-factor, I can't see a clear way of delineating between "arduino" and "non-arduino", unless you explicitly require that the project be compiled using the arduino text-editor, and that will probably disqualify all the decent projects since the arduino editor is horrible, and all the good coders stopped using it long ago.

@FakeName let's take this discussion to the Meta Post

Stateful questbox
A GPS powered box that makes you visit a few spots before opening
Description
It is similar to questbox, but it stores a small amount state of information in EEPROM, so you have to visit two or three different places before it opens.
Design
Needed hardware:

Arduino Uno
Reverse Geocache Version 2 (or a protoshield)
GlobalSat EM-406A GPS module
2×8 blue LCD with connector header and cable
Hitec HS-55 servo motor
4-40 push rod and clevis for latch (some versions provide a Z-bend rod instead)
2 AA battery holder
Metallic push button with embedded blue LED and 4-pin cable
Pololu low voltage switch
Pololu 5 V boost regulator
JST connector for EM-406A GPS module
Straight and right-angle header pins for the display, servo, and pushbutton connectors
Two resistors for current limiting and display contrast adjustment
Two small capacitors for power smoothing
larger capacitor for display contrast circuit

Total hardware cost: 137$ + shipping
Aditional materials:

A nice box
Epoxy glue, wood to cover pieces, tools

You can find assembling instructions in sundial page (you can buy most materials from them)
I will upload stateful code and post a link here, unfortunately I wont get all need hardware on time, so this is just an idea :)
Code written so far:

Persistent state machine library

Inspiration:
Conclusion
Learned how to integrate many components and libraries all toghether, I'll have to travel a bit to test it :)
Budget can be cut quite a bit changing the concept a bit:

Change GPS with a numerical keypad: the 'player' has to guess/obtain a code instead of traveling to a location
Polulu switch and regulator can be exchanged for a latching relay with capacitance coupling

Energy saver for the absent-minded PC user
This device switches on/off my desk lights when it is dark(ish) and in sync with my PC screensaver.
Description
The project is little more than an combination of a light sensitive sensor, a relay and some smart code that monitors the screensaver on my PC. When it is dusk and when screen saver is not active, it switches on the lights over my desk. When I subsequently leave my desk the screensaver will activate, which will in turn trigger the desk light to be turned off. When there is enough light during day time, the lights are not switched on at all. The problem solved is to reduce the waste of energy due to the lighting in my office being switched on when I have left the room.
Design
Because the power of microcontrollers / Arduino only a little extra hardware is required to create a useful project. The same goes for this project where the hardware is little more than:

An Arduino
A couple of screw shields to connect the external components
An LDR in series with a resistor to measure ambient light
A relay card to switch on and off the mains powered lights
A 10 μF capacitor from GND to RST to prevent the board from being reset and accidentally being programmed.

simulate this circuit – Schematic created using CircuitLab
Conclusion
I learned how to interface the PC over the USB serial link with Arduino and how to read current state of the screensaver on my PC. If I would start over, I'd use a much smaller controller as I really only need a single digital output and a single analog input. Probably base the project on V-USB. Arduino however is excellent for the quick and easy proof of concept (PoC). (The PoC has been on my desk for at least two years already).

It'd be cool to see pictures of your final board and setup. What's the response time like? Instant? After a minute?

@sachleen The daemon on my PC that polls the screensaver runs every 30 seconds when the screensaver off (when I'm working on my PC) and every 5 seconds when turned on. I can increase that speed, but that influences CPU load and with that power use... There is also a capacitor attached to prevent the Arduino from resetting and accidentally being programmed.

@sachleen as dusk falls slowly over time, this 30 seconds isn't really an issue. Nobody notices the difference in darkness over 30 seconds. Within 5 seconds of moving my mouse or hitting my keyboard when I return the lights turn on. There is a slight hysteresis betweet what is considered dark and light, to prevent the lights from turning on/off every so many seconds when it is sloowwwwly getting dark enough to get activated.

You should modify it to dim it at 50% for 10-15 seconds so you're not in the dark completely and it gives you a little "warning"

@AnnonomusPerson I am switching the 240VAC side of a SMPS that is spec'd 100-250VAC input. Not going to happen I'm afraid as I don't want to switch secondary side. Nice idea though, maybe I can add a smart small white LED somehow.

Sonic Ray Gun
Two projects by kids
I'm working with a couple of home educated kids and we are having a lot of fun with an arduino. Their first project was a fake-bomb, like you see in the movies, with a LCD countdown timer and a classic "do you cut the red or blue wire?" type problem.
Project two started with showing them the toneMelody example and a small speaker. The quickly found out that if you turn the frequency up to 15kHz it was rather annoying to teenagers. An hour later they had improved the design with a cup, toilet roll and a switch made from a paperclip making a directional sonic ray gun.
Sadly no pictures.
Conclusion
Don't leave kids unattended with an arduino.

Can you describe it a bit more (code, Fritzing, etc?)?

I think this kind of barely fits within the rules, but it's interesting enough that I figure I'd post it anyways.
High-Precision, GPS-Synchronized timestamp generator for data-acquisition purposes.
This is a rather interesting project that is intended to be used for providing a easy way of synchronizing multiple independent data-acquisition systems.
Basically, I work in a research lab, and we often have instruments that have multiple independent data-acquisition systems, which can be physically separated by as much as 50 feet. We need to be able to correlate the time at which samples from each system were taken, which can be difficult if you want to resolve sampling-times to a great degree of precision. Using something like a USB data-acquisition system, just the USB latency can introduce several hundred milliseconds of unknown latency, that can vary from acquisition to acquisition.
The previous solution was a 24-bit parallel counter that was simply bussed everywhere, requiring an enormous wiring harness, and was kind of a pain in the butt.
This system uses a specialized timing GPS module that can synthesize arbitrary frequency clocks, that are phase and frequency locked to the atomic clocks in the GPS satellites.
The MCU is responsible for tying together the GPS data messages (I had to heavily extend and optimize a existing protocol parser for the GPS data). The GPS is configured to use a proprietary binary protocol, and it's all parsed by the parser I wrote.
The project has gone through a number of revisions (pictured below).
Design
Revisions!

Rev 1: Never worked, due to the fact that I was initially hoping to use a software dPLL off a much less expensive GPS, to synthesize a higher-frequency clock from only the 1 PPS output. It's probably possible to make it work, but the time-investment just made it not worthwhile. (and I'm too crappy a coder)
Used a parallax propeller MCU. The lack of decent compiled languages was a major issue as well.

Rev 2: Shifted to a ATmega2560. Worked, had lots of funky design aspects inherited from the first rev. Primarily, the continued use of shift-registers for the 32-bit output, despite the more then sufficient number of IO on the ATmega2560.
First board that ran Optiboot, and was actually programmed entirely using the standard Arduino toolchain, before I got irritated with it and started modifying the toolchain to better suit my purposes.

Rev 3: Also worked. The bodged wiring is because this board incorporated a built-in USB hub to reduce the number of required USB ports (the FTDI interface requires 1 USB, and the GPS has a USB interface as well). Unfortunately, the GPS wouldn't properly enumerate, though the FTDI device worked fine, and I've used this hub elsewhere without issue. Weird.
I don't have a proper USB debugger, so I just dropped the USB hub entirely, rather then trying to fix the issue. The GPS usb isn't really used much outside of set-up anyways.

Rev 4: Semi-final ATmega2560 version. Added a LCD for GPS status, fiddled with LEDs and so forth. Also, better footprints for the possible super-capacitors for maintaining the GPS status when not powered.
This is the last Optiboot version.
MStime is the MSTOW, or Millisecond-Time-Of-Week, which is the name of the GPS data value that is output on the timestamp out. It's a 32-bit variable that increments once per milliseond, and rolls over each week. It's a more obscure part of the GPS standard.
ITOW is another GPS-related value, being a value that corresponds to the 1PPS signal. The correlation between the two isn't properly reflected on the LCD, since I do not have the CPU time to update the LCD at the rate I'd like. This was actually one of the major things that improved in the upgrade to the Xmega devices.

Rev 5: Complete architecture switch. Now uses a ATxmega128A1U processor. Not really "Arduino" at all anymore, but the ability to have multiple interrupt levels on the xmega processor series allowed me to considerably improve the code structure.
The two bodge-wires are from me doing some experimentation, the board worked fine without them as well.
Looking forward:
Rev 6!

Add the ability to use different LCD sizes, more ESD protection on GPS antenna connection (that was an issue), ability to use a CR2032 battery for maintaining the GPS clock instead of super-capacitors.
Also, much better labeling of debug and status LEDs.

And bonus Nyan-Cat!

(These boards are out for fabrication right now. When I get them, I'll add pictures of the real board.)

I did some long-duration testing between two of the ATmega2560 boards, and over 72 hours, the RMS time-error between the two units was ~20 uS. This was with two completely independent antennas too. My design goal was < 1 ms, so I'm pretty damn happy with that.
On the whole, I think this does a good job illustrating how Arduino can be a useful tool for
early prototyping for "real" products/systems. I use it for getting an initial test-version running with minimal effort, and when I'm confident the idea will work, I actually put the work in to migrate away to a completely custom, purpose-specific implementation.

Design files:
https://fake-server.no-ip.org/svn/FPGAStuff/DAQ%20systems/
(In the "GPS Timestamp" series of directories).
(Note: Files are from Altium Designer. The are not eagle files).
Source code:
https://fake-server.no-ip.org/svn/Programming/Code/AVR/
Again, in the "gpsTimeStamp" series of directories.
Sorry for the crappy cell-phone pictures.

Could you please reduce the number of pictures? 3-4 should be sufficient to get the idea across. It takes a fairly long time to load on slow connections.

@AsheeshR - I strongly disagree. I could drop one of the pictures from the last rev, but having the progression of system design I think is quite valuable.

Having fun with the silkscreen?

Oooh, 3D view PCB. Aww, it's Altium and pretty expensive? :$
Pretty fun to see these projects, or to see whatever projects others are doing..

(fake) Linux on Arduino
I recently acquired a small composite LCD screen, which I quickly began playing with using the Arduino TVout library. What came next? Linux!
Description
While playing around with my TV screen and the TVout library, I discovered there is a premade terminal handler for the TV. I soon began to experiment with using it as a TV terminal hooked up to a PS/2 keyboard. There were some problems with the PS/2 library I used, so I transitioned it to use the USB library on my Mega ADK along with a USB keyboard. That worked much better. Now for storage.
My SD card shield isn't compatible with my Mega, so I wired it up somewhat haphazardly to the SPI at the end of the board. I wrote command handling to preform a few tasks like listing files and finding disk size, free space, etc.. The entire assembly isn't by any means finished, but I am happy with the progress I have made.
The code will be relocated to Github eventually, watch the comments.
Design

Challenges
I had a lot of trouble concatenating the inputted charactars to the string storing the current command because I wasn't casting right. Once I got that figured out, I also needed to fix the problem where some keys printed random garbage to the screen. This was caused by reading memory before the letter definitions, so a few ifs cleared that up.
Conclusion
I am very satisfied with the code. Once I add a few more utilities to it, I will put it on Github, so watch the comments. Overall, it was a very fun project. I learned how to use Stino in the process.

This sounds interesting. I would really like to see your code soon!

Code!! Code!! https://github.com/red-green/fakeLinuxonArduino

Did the LCD cost a lot?

@AnnonomusPerson only $17: http://www.amazon.com/3-5-Inch-TFT-Monitor-Automobile/dp/B0045IIZKU/ref=sr_1_1?ie=UTF8&qid=1395696303&sr=8-1&keywords=mini+tv

@AnnonomusPerson i disassembled it because it was too bulky

Cool project. Idea for the future: make it as a flash drive that you can control via the Linux(like) console.

BTW the reason I deleted your comment (on ShiftLCD) was, although I knew that link, I wanted to verify he used the Arduino bootloader. If I would've said Hey did you use the Arduino bootloader on that link? If you didn't the entry is disqualified., most likely he'd say he used it, even if he didn't. It's a sticky situation, and actually I hate my mouse :P (Not button-happy) I appreciate your effort though...

TV Antenna Rotator
IR remote controlled antenna rotation
Can't get off the couch to adjust the direction of the TV antenna?  And even if you do, sometimes your proximity to the antenna changes the reception.  It would be nice to be able to adjust the antenna from the couch.  Using the TV remote.
Components
Arduino Uno,
IR receiver,
Stepper motor w/ driver board,
1" ID bearing,
Swiffer mop handle,
Plastic box,

Description
Use an old Swiffer mop handle as the antenna post. Got a 1" ID bearing from  my favorite online store, which the mop handle just squeezes into and stops.  I drilled a hole into the plastic box big enough for the mop handle to fit through, but not for the bearing.  I drilled a rectangular hole into the mop handle end to fit the shaft of a 28BYJ-48 stepper motor, and stuck the contraption into the box as shown.  The mop handle actually rests on the bearing, and the bearing is super glued to the top of the plastic box.
Used the stepper.h library to rotate the motor from an Uno.
I took apart an unused DVD player and salvaged the IR receiver from it.  You can take apart any consumer appliance that has a remote and use the IR receiver from it, it'll work.  The IR receiver uses the IRremote.h library.  Using the serial monitor, I printed out the hex code that corresponded to the two buttons on the TV remote that I want to use to operate the antenna motor.  One for rotating left, one for right.
To save energy, use the small_stepper.motorOff() function to turn off the coils after each movement.
Conclusion
This was a fun project that was also useful for my wife.  I didn't implement any acceleration/deceleration in the movement, which might be nice, especially if the antenna had more rotational inertia.
Edit:  sorry about the picture being sideways!  It's right side up on my computer, I have no idea why it's sideways online.

ShiftLCD
AVR based, Arduino compatible, board that mounts to the back of an 8x1 up to 20x4 Character LCD Screen.
Description
I just designed this board and the custom library to make it easier to use and LCD. Though they are pretty easy to use at the moment. It cuts down the number of output pins used from 6 to 3. It also has the option to expand the I/O by adding more shift registers on to the one that drives the display. The processor used is an ATTiny45 or ATTiny85 which has, after using the shift register, digital pins 1 (PWM) and 4 available and analog pin 2 (same pin as digital pin 4) available.
Design

OSH Park permalink which has parts listed
Arduino Library

Challenges
One unforeseen challenge I faced was when I started I was using digital pins 0-2 to run the shift register, these also happened to be the programming pins (MISO, MOSI, SCK). So every time I reprogrammed the device the LCD would get sent a whole bunch of gibberish messages where the power would have to be turned off in order to reset the display. I solved this problem by moving the shift registers latch pin to digital pin 3 which is not a programming pin. Solving this also solved another problem for me because when I moved the latch pin it opened up digital pin 1 which had PWM usage, allowing for more things to be done with the board.
Conclusion
Granted this may not be the coolest product or idea, it still has its uses. The answer the question directly, "What did you learn from doing this project" I learned how to design from start to finish a PCB board. If I could do anything differently it would have been to use surface mount parts instead of through hole, then again it is just a prototype, one-off board.

How did you program your ATtiny? What code was involved? IDE? (Please just comment, do not edit your post.)

@AnnonomusPerson Looks like the person who posted what I did before removed their comment, so this is the where I got the things needed (Arduino IDE files and programming schematic) to program the ATTiny. http://highlowtech.org/?p=1695

Why use surface mount? Soldering through-hole at home is much easier? I think SMD is only for production runs, or is there something else to it?

Button-pushing robot.
A four-wheeled eight-pound remote-control laser-shooting robot that pushes buttons.
Description
I made this project over the course of last school year. I was in robotics class, and we decided to have a competition. Each team would make a robot that has a large button and a way to push other buttons. At the end of the year, we would have the final contest, where the three robots would try to push each other's buttons.
By the end of the year, my robot only partially worked. Every part of the robot had at some point been working, but between a fried Arduino, fried motor drivers, terrible code organization, and me being the only person on my team to work on the robot for a total of more than five hours, I couldn't get it completely working.
I haven't touched my robot in almost a year, so I know that if I wanted to get it working again I would have to rewire the bot and rewrite the code. I may decide to do that some day, but for now I'm going to work on less ambitious projects.
Design
Overall Design

Information/electricity flow
+--------------------------+   +-------------------------------------------------+
|         Computer         |   |      Robot                                      |
|--------------------------|   |-------------------------------------------------|
|                          |   |                                                 |
| Keyboard +--> Processing |   |  Button +-------------+        Motor    Motor   |
|                          |   |                       |          ^       ^      |
|                    +     |   |                       |          |       |      |
|                    |     |   |  Batteries +-----+    |          +       +      |
|                    v     |   |                  |    |   +----> Motor Driver   |
|                          |   |                  v    v   +                     |
|               Bluetooth +-----> Bluetooth +--> Arduino Uno +--> Motor driver   |
|                          |   |                  +    +  +       +       +      |
+--------------------------+   |                  |    |  |       |       |      |
                               |                  |    |  |       v       v      |
                               |                  |    |  |    Motor     Motor   |
                               |                  |    |  |                      |
                               |                  |    |  |                      |
                               |                  |    |  +-----> Laser          |
                               |  +---------------|----|----+                    |
                               |  |       Arm     |    |    |                    |
                               |  |---------------|----|----|                    |
                               |  |     +---------+    v    |                    |
                               |  |     |      Motor Driver |                    |
                               |  |     v              +    |                    |
                               |  |  Servo             |    |                    |
                               |  |                    v    |                    |
                               |  |                  Motor  |                    |
                               |  +-------------------------+                    |
                               +-------------------------------------------------+

Components

Arduino Uno, (fried)
Transportation:

2 motor drivers, (one fried)
4 wheel motors, (24v, 360mA with no load)
4 wheels, (plastic jar lids)

Easy Button
Arm:

Servo, (continuous rotation)
Motor driver, (fried)
Motor, (12v, found in teacher's junk pile)
Eraser
Counterweight, (homemade paper bag filled with pennies)

2 battery packs, (12V, 1300mAh, Ni-MH rechargeable)
2 solderless breadboards
Laser, (5mW)
Bluetooth:

mdfly Bluetooth module, (5v, 30ft)
Bluetooth adapter, (USB, 300+ ft)

Lots of wires
Lots of scrap metal and plexiglass, (found in teacher's machine shop)

Code
I didn't organize my code very well, so I hope this is the right code.

Arduino: https://github.com/TheGuywithTheHat/robotics-2013/tree/master/Arduino
Processing: https://github.com/TheGuywithTheHat/robotics-2013/tree/master/Processing

More pictures

Terrible video of a slow, armless, buttonless, laserless, and bluetoothless early version of the robot.
https://www.youtube.com/watch?v=Q7MvE7-Xb0E
Conclusion
I'm really good at frying electronics.
This was my first experience in an actual machine shop. I got to use a CNC milling machine, manual milling machine, lathe, and bandsaw. If I started a project like this again, I would make much better documentation, so I could figure out what the heck I was doing a year later.

Nice work! Nothing is as valuable as experience and the important bit is that you now know how to do a better job next time.

- Learn how to create your own low cost wireless sensors and connect them to the world.
http://www.mysensors.org
We call it "Internet of Your Things"
Description
We've combined the Arduino platform with a small radio transceiver into a fun, flexible world of low cost wireless sensors.
All the nitty-gritty details about the sensor communication has been packaged into a convenient software library so you don't have to worry about them.
It is as easy as 1, 2, 3.

Connect the parts. 2. Download the provided examples. 3. Start measuring and controlling the world!

Read more about how the sensor network is automatically being formed using our Arduino Library on the site. It basically forms a star network and can reach hundred of meters.

In the middle you place an Arduion or Raspberry gateway that collects the information from your sensors.

Design and schematics
Here is one of the prototype motion sensors I created to control the garden light outside of my house. The motions status is sent to my HA controller which turns on the light (via z-wave) when motion has been detected. A light sensor (not in the image) makes sure only to turn on the lights at night.

You will find all the build instructions here:
http://www.mysensors.org/build/
Othe site there is also easy-to-follow build instructions for a bunch of other wireless sensors and actuators. Here are some examples:
Distance Sensor, Motion sensor, Relay actuator, Humidity, Light, Pressure, Rain, Temperature, ...
Conclusion
The project is still in the starting blocks and we hope to provide plugins for a growing list of Home Automation controllers. The first thing on our list right now is to provide a DIY controller that provides a free cloud storage for your sensor data.

See you @ mysensors.org
/Henrik Ekblad (the creator of the Open Source Arduino Library used for the communication between the sensors)

UPDATE 27/3. Made the example more concrete and added my affiliation with the open source project.

Welcome to Arduino.SE! I'm afraid your website doesn't fit the criteria of our showcase. We're looking for specific projects which demonstrate a practical application of Arduino (as seen in the other examples here). Perhaps you could provide an example of a sensor project you've built?

Ok, maybe i'm missing the point ;). The "specific project" here is that we use Arduinos to create self healing wireless sensor network. To archive this we have created an Open Source Arduino library for the NRF24L01+ transceiver.

This sounds more like an advert than a project. Change the tone, maybe make it a bit more specific to a single application. I suspect that is why you got a down vote.

Welcome to Ard.SE! Based on your profile website, you work at or own the site being promoted above. It is SE policy that you disclose this in your answer. Please edit it to include that. Also, can you add an example of using this?

I've been developing this (Open Source) MySensors library for the past 6 months on my free time. To help other people use the library properly we (more people have joined the project the last couple of months) launched the build-instruction-page just 3 days ago. I thought it would be a good Arduino project to get feedback on in this "Project Showcase". I don't think I've tried to hide my participation in the project in any way and I'm sorry if the description is perceived as an advertisement. We are just very happy about the project!

It looks cool... however can you use the "edit" button to add your affiliation and maybe a practical application?

I'm pretty excited about this project.  I've been waiting for a Raspberry Pi implementation of a sensor network.  It's more of an enabling tool so others can focus more on getting stuff done.  I understand the other comments here about how it might not have fit within the Showcase thread objective, but in terms of letting others see how this tool can be used on their projects, I think it's valid.  Just think of all the cheap wireless sensors you can scale up to with this.

The Knock-knock lamp
A lamp that toggles on/off when the desk is knocked on. Currently in alpha phase, still prototyping, but I think it's the most useful Arduino project in existence. Included corny joke generator... from previously recorded knock-knock jokes. Note: I know I can't win in the rules, but there's no rule about entering... I can show off my project, too.
Description
So far I've pretty much explained most of it. You knock, and the light turns on and off. I'm currently on breadboard. I'm using a piezo element to detect the knocks with vibrations. In parallel, I have a 1 megaohm resistor to protect my Arduino Uno SMD.
I thought of this design after nearly knocking (haha punny) my lamp off of my desk while searching for the little toggle switch. I'm not exactly... well adroit. It's nice just to knock on the desk and then have light. I'm also using a Power Switch Tail SSR (solid state relay: no noise) to control it with two of my Arduino's pins.
Design

Image taken with webcam hanging over monitor... eek!

Components used to build the project:

Piezo element ($3.00 USD)
Megaohm resistor ($0.30 USD each in 5pk)
Arduino Uno SMD (on hand)
Power Switch Tail SSR (~$25.00 USD with ship, but had on hand so no cost)
Breadboard and jumpers/extra wire (~$5.00 USD, but had on hand so no cost)

Cost to me: $3.30 USD + $0.02 USD (tax) == Only $3.32!
Conclusion
Overall, it is a simple project but it's actually useful. That's a struggle with my Arduino projects: can I build something that I would actually use? Blinking an LED isn't exactly going to help you in life. It's fun, but that's about it.
The biggest issue I faced (and kinda still do) is not getting a strong enough signal. I learned a lot about electrical signals: I figured out how to find the "peak" of a pulse and not just read the pin at a random interval and miss the higher voltage. I would try getting  more sensitive piezo element. A larger one would help. I'm trying to modify my circuit to not limit the voltage as much, but protect the Arduino. Some sort of fuse would help in this situation. I'm also playing around with resistor values. It'd help a lot to have a scope for this, but I guess not... :P
After I perfect the circuit, I'm going to work on getting it on a PCB with an ATtiny... and maybe even develop some kits. I'll try to publish my findings on how to make the element more sensitive without risking my board in the process.
Status update: I've been really busy recently. I'm going to order a zener diode (4.3V) here in a week or two to remove the megaohm resistor to prevent diluting the signal while protection the chip. I may build a simple voltage amp here if needed (alongside the zener) to try to make the sensor more sensitive.

Moving to something with differential and gain ADCs would help you get more sensitivity out of the piezo. And possibly using a TVS instead of a resistor.

Are you using ADC for detection or an interrupt? Any idea of how large the voltage peak is you want to detect?

@jipie ADC for detection, I have fairly efficient code: it loops and finds the peak for every 250 ms. No delays. For peak, IIRC it's around 14/1024 (too lazy to convert that now). I should look into the AREF pin too, but there might be problems with if it's dropped it can make ~9V.

Try this as input buffer. The transistor acts as a current amplifying half wave rectifier / peak detector. No need to detect a single peak with the ADC, the transistor / capacitor will strech it for you. As configured the output voltage has a 2.2V DC bias, but you can change that to anything you prefer by changing the resistive divider. That way you can make the input even more sensitive by selecting the 1V1 or 2V56 bandgap reference. The 10M resistor ensures the capacitor discharges over about a second and was in reality my DMM.

Digital Wall Clock with Radio Frequency (RF) Remote Control
A large (40x30cm / 16x12") 7-segment display wall clock with R/F remote control.

Description
This project features a large (40x30cm / 16x12") 7-segment display digital wall clock with R/F remote control. It has the following features:

It shows the current time and date (hours, minutes, seconds, day, month, year) in two formats (hours or date in the large digits).
It shows the current temperature in °C.
Has a user defined countdown which will sound an (annoying) alarm when it reaches zero.
All functions controlled remotely by an RF remote control.
Has a small cursor keypad for controlling its functions (when the remote control isn't available).
Brightness control independent for each display line.
It continues to keep the current time accurately even when off, thanks to a real time clock IC powered by a coin cell battery.

Design
The key aspects of this project were the following:

It's completely based on Arduino and AVR ATmega328 microcontroller.
It keeps current time even when off, thanks to DR1307 RTC powered by a coin cell battery.
The digits are never multiplexed. Instead, each digit has a dedicated 8-bit serial shift register IC (74HC595) that keeps selected segments on independently of what's being displayed on the other digits and what the MCU is doing.
Segments are powered by Darlington arrays due to current consumption that exceeds that of the MCU or the shift registers.
The clock is controlled by a keypad on the controller board and also by an RF remote control. Radio communication is performed by a pair of inexpensive 434MHz radio receiver and transmitter.
The project has a modular design in which a single controller can manage up 12 single digits. Controller also accepts expandable modules for unlimited number of digits (maximum number of digits is limited by timing delay due to daisy chaining of shift registers and the attenuation of their clock signal).
The design supports a number of ready-made 7-segment display digits or custom digits made with LEDs.

Below are the schematics for the controller and one of the 7-segments boards:

Here are some pictures of the boards that I designed, etched, and assembled, and the remote control:

And finally, here's a picture of another version of the clock. In this one, I'm making the 7-segment displays myself using rectangular LEDs and discrete components.

Conclusion
This project took me a lot of time, effort and learning to get to this stage (it's never finished, as I've learned), but it was lots of fun. A few things I've learned:

Study all the libs you're going to use in your project before you assign GPIO pins in your controller so you avoid potential conflicts. I've been unlucky to use the same PWM pin for brightness control that is associated with VirtualWire timer, so I had to patch the board to get brightness and RF working at the same time.
Crimping KK molex and modu connectors takes A LOT OF TIME!!
Laser cut acrylic pieces are the future. They add a lot of quality to the device even if you are clumsy.

How did you make the PCBs (etching and drilling)?

@sachleen I use the toner transfer method with ironing. I print the board design into ink jet photo paper in a laser printer, then I iron it onto the board, then I etch the board in FeCl. It takes a while to find the right paper and printer settings. I use a dremel drill press for drilling, but I only use phenolic boards and high speed drill bits. Fiberglass boards are much harder on the drill bits, usually requiring the more expensive and brittle carbide drill bits.

Where did you get those LEDs? I have some that look exactly like that!

@TheGuywithTheHat The green rectangular ones? Those are pretty common around here in Brazil. I got those at one of our online electronic components shop. Here are some links: at DigiKey, at eBay. Here's where I got them.

4-Digits LED display for Arduino
Small board with 4 7-segments LED digits, managed through 3 pins.
Description
When I started working with Arduino, I wanted a way to display values collected by various sensors I experimented, but I did not want to output these values through Serial to a PC.
I wanted a small board that I could easily reuse from one project to another and I wanted to spare a breadboard.
This board, along with its small library, currently allows 4-digits numbers display and does not source any Arduino current during display (current is sourced only when communicating to the board the new value to display from now on).

Design
The design is rather simple as I decided to reuse a MAX-7219 chip to drive my LED display (I had a few of them on hand).
Thanks to this chip, the schematic was much simple, but it was important to correctly understand how to use it; fortunately, its datasheet was pretty clear.
The original design was done on a breadboard and used 4 single LED 7-segment digits; but it required too much wiring for my taste (need to connect segments by groups of 4). Also, during my very first experiment with 7-segment LED digits, I have fried one: it had 2 Ground pins, but I connected only one to GND instead of both :-(
Then I decided to go for a 4x7-segment display, common cathode, with segment anodes already connected for 4 digits: that's only 4+8 pins!

During my tests, I have found a useful Arduino library for working with MAX-7219 which I decided to reuse. I have built my own library upon it, with a very simple API.
After breadboarding, it was time to make the design more permanent; since I had a bunch of stripboards on hand, I decided to go for it.
I searched and found an easy Stripboard designer for PC that I have used for designing my board.
The first stripboard design was not optimized in terms of space and I decided not to implement it:

Then I have reviewed the design to optimize the cost and size (just one small 50x75mm stripboard); that was easy with the stripboard designer I found before:

Once the board was ready, I decided to check it with an Arduino UNO and an Ultrasonic Sensor:

It seemed to work except I often had strange, inconsistent displayed values; after investigation, I found it was due to noise triggered by the display board, noise that interfered with the sensor. I just needed to add a decoupling cap as near the current supply pins of the sensor as possible and that worked perfectly (note that the display board already had decoupling caps for the MAX-7219 chip).
Parts list:

1 x LN5461AS:    common cathode 7-segments block of 4 digits
1 x MAX7219:     multiplexed LED driver chip
1 x IC support (24 pins)
1 x 22K resistor
1 x 10uF electrolytic cap
1 x 100nF cap
1 x male pin header (5 pins)
1 x 90x50mm stripboard
wires, solder...

Conclusion
30 years after my last electronics experiments, I could get the virus again with Arduino and with this very first project which, although rather simple, taught me several things:

interpret datasheets for the components used (MAX7219 and LED display)
learn how to use and be effective with stripboard design
all pins marked GND or V+ should be connected: you don't choose the one you feel like connecting!
if there's something that appears strange when you test your circuit and you don't understand why: don't search, it must be noise, try to add a decoupling cap and that should do it!
learn how to create an Arduino library (not just a sketch)

If I was to start this project again today, I would:

try to optimize further the stripboard design (probably I could reduce the size a bit further)
replace the straight pin headers on the board with right-angled headers so that wires connecting to Arduino are more protruding in front of the board

Serial Box
A portable serial monitor in a box
Description
Sometimes it's useful for a device (Arduino or otherwise) to output some debug information via serial. That's great if you've got a computer on hand with an appropriate serial input. However, that's not always the case for a variety of reasons.
This project is my attempt to address that problem by creating a portable Arduino-powered serial monitor, which I can hook-up to other devices in the field.
By default, it will simply display text in a scrollback format; i.e. text appears on the bottom line, and everything scrolls up to make room when more arrives. This means it should work very neatly with all sorts of generic devices. However, it will also be possible to use escape sequences to control the display more precisely, so that devices can also be programmed specifically to take advantage of its capabilities.
Design
The design consists of a set of 4 alphanumeric LCD displays (16x2 characters each), aligned in a box something like this:

The displays are Epson EAX16027AR's, which unfortunately are not compatible with the standard Hitachi HD44780 driver. As such, I had to write my own library for them.
I chose to use these displays (rather than e.g. one large display) mainly because I just had them lying around, and wanted to do something interesting with them. I also thought it would be quite handy to be able to control each display independently for some applications (e.g. displaying different information on each one).
In terms of circuit design, the displays are connected in parallel, with chip select pins being used to direct data/commands to each one as needed.
An ATMega328 will be the brains of the final unit, with serial data coming from a TTL-level line (for connecting directly to the TX of a similar MCU), or optionally from an RS232 9-pin D-sub socket (for connecting to various other systems). The unit will also have a contrast dial, a button for clearing the display, and a button for initiating a self-test mode. In future, I'd like to add buttons which let the user move through a scrollback history too.
Below is a very preliminary circuit layout (I had a lot of trouble getting Fritzing to play nicely for some reason!). It includes an 8-bit SIPO shift register for driving the LCDs' data lines, which are shown in green. You can also see the chip select lines in orange.

At the moment, the project is still at the working prototype stage, driven from an Uno (clone) board. Below, you can see a photo of it in action, displaying text which was passed via serial from my computer.

Source code
I'm making my LCD library available on GitHub at the link below. Please note that it's at an early stage in development. In the near future, I intend to make it much more similar to the core LiquidCrystal library so that it's easier to transition between the two.

https://github.com/avid-insight/LiquidCrystalEAX

You can find some basic code for my Serial Box prototype in the "examples" folder.
Conclusion
I think the project is coming along very nicely, and I was extremely pleased to get the prototype working. My main challenge is going to be mounting the whole thing in a box. I've already made a start on cutting out suitable holes for the displays, but I'm not very experienced at that sort of thing, and am finding it quite tricky to line everything up.
I'll get there in the end though. It just may not look very pretty by the time I'm finished! :)

Heating Controller
You know how it is - you set the heating to come on at a certain time and how many days do you work late and it's been on full bore for hours, or you go away for a few days and forget to turn it off? Or the rare occasion that you get home early and the house is cold? I decided that the simple way to get around this was to build a device that would allow me to turn my heating on or off by text message / sms. It would be in addition to the existing control system so as not to lose the flexibility which that can provide.
The project consists of a few major parts: an Arduino Uno clone, a Seeedstudio GSM shield, a DHT22 temperature sensor and a 25 amp SSR.
How it works:
The existing heating controls are set to 'Off' and the new controller is wired up to override them. The Uno is programmed to respond to three different messages - On, Off and Query. In the case of the latter the unit will read the DHT22 and reply to the sender with the current temperature and the status of the unit (on or off). If the command is either On or Off then it will respond with a confirmation of the action carried out. Once messages have been acted upon they are deleted; any messages that do not conform to the specific message structure are left in the SIM card memory and can be examined later if desired.
Power to the unit is supplied by a five volt three amp switch mode power supply. As the power pins on the Arduino are simply exposing the board's internal 5v bus I decided to power the ensemble through these and configure the shield to draw  power from the Arduino.
The unit has three status LEDs. One green one to indicate that there is power, a blue one to indicate that the GSM board is 'live' and a red one to indicate the status of the heating. These are in addition to the status LEDs provided on the Arduino and shield. There is also a push button switch that allows manual control of the heating, with a 100nF capacitor to handle the debounce.
Next:
Much of the code relies upon good old delay() to give the shield enough time to perform its actions. I plan to improve the code so that it waits for confirmation from the shield rather than assuming that it has done what it was told to within the time allocated! I will also add a 'still alive' feature - at fixed intervals turn off the blue LED, send the AT command to the shield and on an acknowledgement turn the LED on again. The shield is under software control so if it fails to respond then turn it off and back on again.
The whole ensemble is to be mounted in a suitable enclosure and mounted adjacent to the existing controller. I have an internally illuminated push button switch that I will use instead of separate switch and red LED to handle the override.
Longer term I'm planning to add an RTC, a 20 x 4 LCD and additional push buttons to allow the unit to be programmed and act as a time switch as well.
Prototyping has already started!
Conclusion.
There is something slightly decadent about waking up on a cold winter's rest day, sending a text message / sms to turn the heating on, and rolling over and going back to sleep for an hour! And when you realise that you haven't turned it off on a night you can do so from the comfort of your bed!


text:
cannot read from softwareserial
I am able to use AT command from the Serial monitor however when I run the following code nothing is sent or received from the ESP8266. Can someone advise what could be the problem.
#include <SoftwareSerial.h>;

SoftwareSerial esp8266(0,1); // make RX Arduino line is pin 2, make TX Arduino line is pin 3.
                            // This means that you need to connect the TX line from the esp to the Arduino's pin 2
                             // and the RX line from the esp to the Arduino's pin 3
void setup()
{
  Serial.begin(9600);
  esp8266.begin(9600); // your esp's baud rate might be different
}

void loop()
{
 if(esp8266.available()) // check if the esp is sending a message
  {
    while(esp8266.available())
    {
      // The esp has data so display its output to the serial window
      char c = esp8266.read(); // read the next character.
      Serial.write(c);
    }
  }

  if(Serial.available())
  {
    // the following delay is required because otherwise the arduino will read the first letter of the command but not the rest
    // In other words without the delay if you use AT+RST, for example, the Arduino will read the letter A send it, then read the rest and send it
    // but we want to send everything at the same time.
    delay(1000);

    String command="";

    while(Serial.available()) // read the command character by character
    {
        // read one character
     command+=(char)Serial.read();
    }
    esp8266.println(command); // send the read character to the esp8266
  }
}

SoftwareSerial esp8266(0,1)

You can't use pins 0 and 1 for software serial since they are the hardware serial Serial than you use for communication with the PC.
Pick two other pins to use.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
How to implement setSyncProvider and verify it is working with PC
I'm trying to retrieve / synchronize time from PC using this Time lib function:
setSyncProvider( requestSync);  //set function to call when sync required

It sends ASCII BEL (07) character to PC, but I'm getting no response using Serial.available. What am I missing?
Do I have to run a specific app on the PC to get a response? The docs do not specify that.

Yes, you'll need something running on the PC which is monitoring the serial port, and which will provide a response in the appropriate format.
The download on this page contains a Processing sketch which will do this for you. After you've unzipped it, look in Time/Examples/Processing/SyncArduinoClock. Open the sketch in Processing, run it, and then start your Arduino.
If you're not familiar with it, Processing is a free programming language / environment based on Java. It's aimed largely at beginners and non-programmers, and is quite commonly used for communicating with Arduino projects via Serial. You can download it here:

http://www.processing.org

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
question about progmem
I have a problem understanding the following code:
PROGMEM  prog_uint16_t x={1232,3232,43343};
rawlen = pgm_read_word_near(x);
memcpy_P(uSendBuff, pfSendBuff+1, rawlen * sizeof(uint16_t));

Why do we need this? -
rawlen * sizeof(uint16_t));

Why not this? -
memcpy_P(uSendBuff, pfSendBuff+1, sizeof(rawlen));

Probably because x is an array of integers (although in the code you posted you miss the '[]'), thus memcpy_p should run over rawlen integers, each integer occupies sizeof(uint16_t) bytes, hence rawlen * sizeof(uint16_t) bytes in program memory space.


text:
Do I need to worry about voltage, coming from ground, and effecting an analog input?
I am building a project that includes an analog Input and several digital Inputs and Outputs.  All of them connect to ground in some way.  Do I need to worry about voltage, coming from the digital outputs, going to ground, and effecting readings on the analog input?  If so, how do I deal with this?

If you have a different power supply powering the sensors than the arduino then you should connect all grounds so that they are common.  In other words the remote power supply and the arduino's power supple should have common bridged.

The arduino has build in pull up resistors, it is not a residue voltage coming from ground more than a "not 100% 0 volt" resistor.
Even though there is built in pull-up resistors one can add additional resistance to the arduino to make sure it will not show a false positive.
From what i have learned, you cannot experience voltage comming from ground (if everything is properly wired), if you want to make sure. Place a diod in the direction of the power flow, to prevent this.

In what cases would it not be wired correctly?

just to give an example out of many but reversed polarity. or 2 circuit where one might have less resistance.

In this case I do not believe ground bounce will be a problem. I normally only encounter it on high speed PCB designs. You will get noise from the power supply(s). Any impedance induced between the ground of analog input (circuit board ground) and the sensor will give you problems. Be sure all grounds are low impedance in nature. Since  you are designing the project consider and I assume a PCB, filtering the Aref pin supply with a small cap and a 100 ohm resistor. A low pass filter on all inputs will help, a small cap from the input pin to ground and feed it via a resistor. Good capacitors are very important.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
MMA7660 accelerometer with ATTiny85
I'm trying to make the ATTiny85 work with the MMA7660 accelerometer, so far, without any success. Google search for "ATTiny85 MMA7660" gives poor results, and I'm not sure it has been done at all, at least publicly, so I thought I'll try my luck here.
What I've tried is using the TinyWireM library, in different combinations. The last one is based on the MMA7660 Arduino library, specially adjusted to the TinyWireM, and taken from this post in Arduino forums (direct link to download).
The SCL is connected to PB0 and SDA to PB2, with 5k ohm pull-ups (I know that the recommended is 4.7k but this is what I have available, and I assumed it shouldn't make much difference).
I am using the Arduino IDE v1.5.6, which works successfully with other non-I2C attiny projects I have.
As for the final code I am using the .pde example that comes with the MMA7660, altered to use SoftwareSerial:
#include <TinyWireM.h>
#include <MMA7660.h>
#include <SoftwareSerial.h>

SoftwareSerial mySerial(-1,4);

void setup()
{
  mySerial.begin(9600);
  MMA7660.init();
}

void loop()
{
  int x,y,z;
  delay(100); // There will be new values every 100ms
  MMA7660.getValues(&x,&y,&z);
  mySerial.print("x: ");
  mySerial.print(x);
  mySerial.print(" y: ");
  mySerial.print(y);
  mySerial.print(" z: ");
  mySerial.println(z);

}

The current problem with the above code is that the pointers just dump some memory without making any sense. If I try to see what TinyWireM.receive() command returns, values are 216 for all three variables. This is true even when I disconnect the MMA7660 from the prototyping board...! so I assume the problem is with the I2C itself, not working properly. The actual I2C address for the MMA (0x4C) and other relevant code is in MMA7660.cpp.
Any ideas?... Unfortunately I don't currently have another I2C device to examine the health of this protocol with my ATTiny85, so any experience you might have with this sort of configuration will be blessed.
EDIT: I marked dvlabsllc's answer as accepted answer since it gave me the right direction to pinpoint the issue further down the library path. I have opened a new question regarding TinyWireM library here.

I have run into similar frustrations using standard libraries and I2C.  I would have to look into the code and try it out on my own before confirming anything about this particular code; however, in the meantime you might want to try a tool such as I2cScanner that simply scans the I2C bus for all possible addresses and reports addresses that are "alive".  This (or something similar as I am not sure if you are using Arduino API) might be a good start to just see if the I2C is working and that you have the correct address.

I am using the Arduino API. Unfortunately it seems that the I2C scanner was built to use the Wire library, which relays on the Atmega328 built-in I2C chip. I will try to alter it to work with TinyWire.

authors: ΝΙΚΟΛΑΟΣ ΔΗΜΗΤΡΑΚΑΡΑΚΟΣ


text:
Arduino Uno + Ardumoto + BT robot works from USB but not from baterries
My Arduino UNO board is part of a small robot that works when connected to the laptop by USB but it does not when plugged to the batteries. The baterries plug seems okay, it outputs 7.8 V. My UNO is connected to an ArduMoto board that manages the robot motors as well as a bluetooth chip. I have little experience with Arduino or electronics in general so I am stuck on the best course of action.
1) Can I find out what is wrong with the power supply without completely isolating UNO from the robot?
2) If I separate UNO, how can I find out with certainty if my UNO power supply is damaged or not? Is there something in particular that I could measure with my multimeter?
UPDATE
After fully charging my batteries I observed that the LEDs attached to the motor outputs are blinking fast. They blink for about one minute then nothing happens anymore. On USB everything works as expected. Those LEDs show that signal is going towards the motors, but why is it so different to USB? On USB power, the LEDs blink only when I command the robot to move through the BT board while under baterries they blink furiously for a minute and that is all that happens.
I also don't know what happened to the batteries, they seem to be fully drained in just one minute, but I don't know how to test that, they appear to still have high voltage.
I use two LC 18650 4800 mAh 3.7 V UltraFire baterries. The motor shield is Ardumoto Keyes_L298P, very similar to Sparkfun's Ardumoto shield.
I do not have the actual code that is on my Arduino. It must be similar to the code on this page, since I am using their Android app for BT communication with my robot, and it works on USB power supply.

Do you have anything in your code that says while (!Serial); inside setup()?

what happens when you plug in the battery plug? any LEDS on the arduino light up?

Does the basic "blink" example work? If not, then it's hardware. Otherwise, software. A few other things: is battery providing enough current and charged fully? Check both of these with a multimeter. Are you positive that all connections are correct (VIN and ground) and there are no loose connections?

on usb everything works, on bateries dead silence not even a led. to test the basic blink I guess I must replace the current program. I was hoping that I can diagnose the power somehow be fore it bridges with the USB source since that works. Batteries and plug are fine, I only measured the voltage, 7.8 should be ideal right?

Stupid question but you sure the polarity is correct?  The power led should at least light up...  Also, are you using the VIN pin are the power jack... goes to the same place...

Do you have more data about your batteries, and are they fully charged? The current that batteries can provide is super important due to the motors that are part of your circuit.

tx I tried to answer your questions (see the update).

Measure the voltage of your batteries when the led's blink (motor should turn). If you see a significant voltage drop then your batteries are not providing enough current. You can also test this with a dummy load (resistor s should do).

Are you powering the motors with a separate supply, and not direct from the Arduino? Motors should be powered separately and the power only switched by the Arduino. Otherwise, their current draw could be pulling down your battery voltage. And even with USB power, they could be drawing more current than spec'd for either the USB power source or the Arduino's regulator or output pins. The chip itself is spec'd for a maximum current of 40mA per pin and 200mA total.

The motor shield also contains the bluetooth slot and everything is powered through Arduino UNO, either through USB or batteries. I only measured the voltage on the source, but I will try to verify the intensity details at the batteries as well as the Arduino output pins.


text:
How to make an electronic suction cup?
The uArm is a robot arm with a suction cup (or gripper). I'd like to try to make just the suction part of it, and I'm wondering what components I'd need?
By the looks of it, I'd need a hobby vacuum pump, but these seem few and far between on UK components sites.
How would I power it? It looks like they're all 12v, and I believe Arduino gives you 5v?
Exact what components would I need? Do I need any shields?
Here's a short video of the suction cup I'd like to copy:

What do you need to grip (i.e. how heavy)?

@AnnonomusPenguin Very light; one suction cup above and one below a thin plastic bag to pull it open (they're thin and tight together - this was the best way I could think of to open them).

You, of course, could open it with fire... :D If the plastic bag has a long area above the "zipper," you might be able to make some sort of hand contraption, which might work better.

@AnnonomusPenguin The bags don't have zips. Just one open edge and one sealed edge. They're not the easiest to open until you get the nack of it. Suction would definitely be better I think.

Before talking about the electronics parts you will need, you must know the characteristics of the pump you will use: voltage AND current.

@jfpoilpret The main components suppliers here are RS Components and Farnell. I'm looking for the cheapest pump they (or another UK supplier) offer which is compatible.

This kind of pump typically needs current between 500mA and 2A, depending on the model. The selection of a transistor will be based on the current you have to switch with the transistor. It's pretty straightforward to find out a trnasistor that matches current/voltage requirements.

You first need to determine the "strength" of the pump you'll need, based on the max weight of items you want to be able to grip. That will give you a list of pumps and associated motors, with the power they need. Power and Voltage will give you the current. Current and Voltage will tell you which transistor you may use.

@jfpoilpret The weight is negligible, just thin A4 sized bags.

may I know What are the components called in that video called? What are the approximate specifications for this parts ?

Just a note for those who wonder the same and are in need of a vacuum: In theory, you can use Venturi effect (or Bernoulli's Principle; it's basically the same) to create a vacuum. Or go buy an Aspirator pump. Since English is not my native language it's difficult for me to explain it in my own terms, but I'll try to give you a rough idea anyway. (Google it or feel free to answer with a better explanation).
First you need some flow of a fluid or gas (air from a compressor or water from a household outlet are fine). You pass that flow through left-to-right in a T-pipe (I'll call that the "flow pipe"). This will result in a weak vacuum in the orthogonal pipe (I'll call this the "vacuum pipe"), which you can connect to your suction cup.
The strength of the vacuum depends on the pressure in the "flow pipe". That means a higher velocity of your matter in the "flow pipe" is good (either a stronger compressor or smaller diameter of your flow pipe).
If I understand my physics book correctly, a higher density of the matter in your flow pipe will also produce a stronger vacuum. If you need a really strong vacuum, you could even use a water compressor, i.e. high pressure cleaner; but I suppose even a small air compressor will outperform a household water outlet (and you could toggle it from an Arduino with a relay board).
Since the air in the vacuum pipe expands more than many other materials, you could try to replace it with i.e. oil (be aware you'll pull out some of the air/replacement material at the intersection in aspirator!). This optimization is dangerous with a normal vacuum pump, since these usually break when sucking up fluids into their internals.
Also using an aspirator has the upside of not needing to buy a vacuum pump if you already own a compressor. On the other hand, that setup might be even louder (and possibly less efficient) than a dedicated vacuum pump.

There are two approaches I can think of that would work decently. Either a.) suck air out of a "cup," turning off the pump when done. OR b.) have a valve where the arm pushes one part of the bag against the table to squeeze all the air out of it, and shutting a valve attached to the "cup." Then, to release, the valve could be opened. For the suction cup, I'd personally try making it out of a suction cup hanger like this:

Source: http://www.amazon.com/Set-Large-Suction-Hanger-Hook/dp/B00439SCZO
The availability of these might vary by area, so I'm not sure how common these are in the UK. If you find one, make sure that it's pretty thick, with not that large of diameter so it's not too big to work with. I'd then remove the metal hook with pliers and drill a hole in the center. After that, you would need to superglue a tube through the center of the hole and seal it with some caulk.
Like I mentioned earlier, the two options are to a.) suck to grab and turn off pump to release or b.) have arm apply pressure to a flat surface and then shut a valve attached to the tube, creating negative pressure in the suction cup. Then, you could open the valve to balance the pressure and let the item go. I'd personally do the suction approach because, although it is louder and might use a little more electricity, it's a bit easier to build and execute and can grab in the air. I'm going to focus on that.
For the pump approach, build the suction cup (like I said above), attach the tube to one end of the motor with a hose clamp, leave the other hose terminal unconnected, and connect the pump (through a relay) to a 12V 1A+ power supply. You can do this by connecting the + pin of the pump to the "out" (or similar) pin of a relay breakout board, the "in" (or similar) of the relay to the power supply +, and the - of the pump to the power supply's - wire. This will make a circuit similar identical to a switch (the switch being the relay). To connect the relay to the Arduino you will have to connect the relay's logic signal to a pin on the Arduino and then you can just write HIGH or LOW to turn the pump on and off.
EDIT: Forgot to mention, you can use a transistor, too. Also, I illustrated the second method (hopefully it makes this clear).

So there's no way to have the pump on the same circuit without a relay? Your last paragraph is what's relevant to me. It's more the electronics I need help with. As for "squeeze all the air out", I'm not sure what you mean; there is no air whatsoever inside the bags. They're flat - only 1-2mm thick. Thanks for your answer, it's useful!

Actually you don't necessarily need a relay to command the pump, a transistor could be enough, depending on the current needed by the pump. The important thing is that you need a separate power supply (12V if this is what the pump needs) than Arduino 5V output.

@Danny You'll need a relay or transistor; the Arduino can only supply 4% of the current needed and 46% of the voltage needed. I haven't worked with transistors that much, so I can't advise you on that. As for the squeeze all the air out, I meant pushing the suction cup against a surface so the air in the suction cup flows out, through the tube. Then, when you would close the valve, it would try to expand, thus creating negative pressure between the bag and the cup. I'll try making a picture.

I am afraid the second method would require to exercise a high pressure first on the object to hold, that may need an engine even stronger than a pump! I think the vacuum-pump is more reliable here.

@jfpoil Yeah, it was a last minute kind of idea. If it works like I imagine it would, then it would need only slightly stronger arm motor.

You can control the 12v pump using any of the popular methods for controlling motors, Google "Arduino ULN2003" for many examples.

You can't power things like pumps and motors with the power supply from an Arduino. It doesn't provide nearly enough current. It's meant for providing regulated 5V for low powered logic circuits, and nothing else.
What you can do is use a transistor as a switch to turn on and off the power from a suitable external power supply.
If you find a vacuum pump that runs on 12V, get a 12V power supply with enough current to drive the pump, and then use a MOSFET transistor (example link) that will can handle enough current at 12V and can be controlled by a 5V signal to it's gate, and use that to switch the power on and off. Then you'd need a diode to protect the transistor against the reverse current you get from inductors like motors.


text:
How do I interpret the esp8266 "boot mode" message?
Everytime the chips resets, we get the reason and the next boot mode.
ets Jan  8 2013,rst cause:XXX, boot mode:(YYY,ZZZ)
For XXX we can check the meaning here.
For YYY and ZZZ I am not sure but I know it has something to do with this. I think YYY stands for abc where a = MTDO, b = GPIO0 and c = GPIO.
For my ESP12E I am getting boot modes like boot mode:(1,7), thus after the reset, the code doesn't start again. It just "hangs there" forever.
I feel that it is starting the UART routine, because 1 = 001, meaning GPIO2 is at HIGH and the others are at LOW.
But maybe what I want, for it to start the setup() and loop() routines all over again is to activate the "SPI" by setting the MTDO pin to LOW and the other two to HIGH.
Can someone explain me better what are these 3 boot modes and how can I interpret the boot mode?

take the first number, and %4 to extract the boot mode. 99% of the time you want SPI flash, so the error code basically warns you that one of GPIO 0,2, or 15 is screwed up

boot mode:1 - means that you are in flashing/programming mode (GPIO0 is low) - so, your sketch isn't even running - note: I've got 2 ESP-12E's and have vowed never to buy them again - all my ESP-07's and ESP-12F's are rock solid - the 12E's are basically crap that despite being "wired" exactly the same as 07's and 12F's (same circuit with just the different modules) boot erratically into random modes, and fail half way through flashing more often than not

Isn't ESP-12F the same as ESP-12E with a different board? I think I've had that GPIO0 issue in all of them. They should have used other pin than that for boot mode. In every ESP it means that only when you know you'll not upload code anymore, should you connect GPIO0 to HIGH in order to properly configure the boot mode, that's silly. Anyway the only reasons I like ESP-12E is for the USB port, the amount of exposed pins and price.

there's no USB on the 12E, or any ESP module for that manner...


text:
How to access 315mhz signals from household devices, with an arduino 315mhz kit?
Background:
I am looking into automation and I have realized that many of the devices I have around my house transmit 315mhz to their specific controllers.  I know this from reading the labels on the back that say 315mhz
Question:
Is there a way I can use a 315mhz receiver with an arduino to view the signals and log the data based on what happens and mimic certain actions with the transmitter?  In other words can I program the reciever to display every bit passed through 315mhz that is in range?
I know the virtual wire library parses the data before I receive it, but I don't know to what extent?  If I just dedicate the arduino to watch that pin and print results will that tell me what is being sent?
Thanks Very Much,
Joel

That depends entirely on what protocol the 315MHz device you want to listen in on uses

I don't know for sure, I know its 315mhz and it has some type of addressing system.  I was planning to do something like a push a button and see what it sends. Because when buying new components the device has to be synced with it.

The Short Answer:
In theory it is possible to do what you are asking.
There are examples of using an Arduino to send and receive messages at 315 MHz. Such as this example.
Although these devices might not even be compatible with the ones you are using. They may be modulating their signal differently or framing their data differently or at different baud rates or encoding bits differently or a number of other fundamental differences that would make them incompatible.
The Long Not Quite An Answer:
There is more to the problem than just being able to get bits at 315 MHz.
For one you would need to know how the bits are encoded. See some of the answers on this post.
Even if it was a simple high low stream of even width bits. You also need to know what baud rate the bits are being transmitted at so you can sync with it. (Consider 4800 vs 9600 baud, slow I know but just an example. You just got a bit stream, was it 1010 at 4800 baud or 11001100 sent at twice the speed of 9600.)
Not to mention that the lowest level of data is probably not just a stream of bits, but is probably framed in some way and grouped into a byte/bytes. Or has a leader to help lock onto the signal.
Even once you are getting reliable data you would need to know the data structure. Is the data arranged in packets? Do they have a packet header? Does the header contain these packet destination address? Where in the header is this data? How is  the data apart from the header structured? What does it mean?.
Knowing the answers to these questions defines, or is defined by, the protocol that is being used by the transmitter (as others are saying in comments.) But these are only a few simple questions that start to define a protocol. Often this information is difficult to come by. Often in the case of proprietary protocols it is very very difficult.


text:
Which motor (type) to use for an arduino controlled magnetic stirrer?
I am in the process of building my own sous vide machine and like to replace the pump typically found in most commercial machines with a magnetic stirrer unit. I figured the easiest way would be to use a motor to spin a permanent magnet (instead of creating a strong rotating magnetic field electrically). I first started experimenting with some 12V DC fans leftover from an old computer. By either lowering the input voltage or via PWM I was able to obtain appropriate rotational speed (don't ask me about exact speeds, I guess around 300rpm or so). With the project maturing I am not sure which motor (type and/or exact model) to use. I hoped some of you might point me in the right direction for the type of motor or even better, could suggest a specific model. I considered stepper motors or continuous  servo motors. My criteria for the motor are:

easy to control rotational speed between 0 and around 500 or so rpm (for ramp up and variation of speed to increase turbulent flow)
ability to rotate both clockwise and counter clockwise
enough torque at all speeds to spin a disk with magnets attached (weight and inertia probably negligible, the to be used alnico magnets create a field strong enough to lift 0,4kg each)
small axial dimensions
reasonably priced and long lasting
quiet

The following picture shows a commercial magnetic stirrer found in your average laboratory. The blurry white object in the glass beaker is the the so called stir bar or "fish", a PTFE coated permanent magnet. It spins due to the rotating magnetic field created by the actual device underneath the beaker.

After reading more than the first few questions on this site (and reading some meta as well) I wonder if my question should by moved to EE since it isn't really a  arduino specifiy question. Reading and answering on another topic led me to believe asking this rather broad question was still okay-ish. (Maybe it is still interesting for the community since there appears to be a lot of confusion about motors and controlling them in general).

What's the purpose of the magnets? Waterproofing?

I am sorry if my initial question was unclear on the details: The magnets are glued to a disk that is than spun by the motor to create a rotating magnetic field. This field is used to spin a small magnetic rod inside a bowl atop the device. The vortex created by the rod stirs the fluid in the bowl.  I added a picture to the question to clarify the matter

Ahh, I understand now. Writing an answer as we speak...

I'd personally recommend a continuous rotation servo or a brushed DC motor. Personally, for this kind of load, I think it would be easier and cheaper to go with the brushed DC motor. You have to remember a continuous rotation servo is a DC motor with some circuitry so you can send pulses to it to control the speed (although it's not directly proportional to the signal you send).
A servo is the only other option besides a brushless motor; both require a little more circuitry than the brushed motor/continuous servo. The additionally cost more. This blog post covers the differences between brushed and brushless motors.
For driving a continuous, you hook it up to power [depends on your servo voltage], ground, and another Arduino pin and use the servo library to send a signal as a degree (90 = no speed, 180 = full speed forward, 0 = full speed backward).
A brushed you would need a h-bridge that allows you to either send voltage, send no voltage, or send reverse voltage (for backward). This chip (~$5) does that for two motors and allows PWM for different speeds. It also includes a brake function, although that doesn't seem necessary for you. It can handle up to a "2.4 A continuous (4 A peak)." I talk about this in this answer of mine.
Quick note, if you want to control the exact RPM of the device and not just manually adjust it to a good rate, you'll need some sort of a rotary encoder or similar. A reed switch (sends current depending on magnetic fields) would work perfectly for this purpose, just mount it below the magnets and figure out the degrees rotated by the motor for each "pulse."

I feel kind of biased towards something brushless since the whole thing is a gift and thus eliminating parts that wear and tear is probably a good idea. One thing I didn't mention in the question is that I have to control up to three motors (big bowl of water). Do you think in that case using servos to minimise surrounding electronics is the way to go?

@Sascha You have to pick that, I can't pick that for you. From experience, steppers (like brushless, just a little differently configured) are 5 times as much as a brushed. Ignoring money, brushless are better, but they are more complex to run. Although this might not work, I personally might just say If a motor goes out, I can fix it or whatever, but I don't know your situation exactly.

currently I am checking ebay (germany) but can't find anything useful since almost every motor appears to be either way to overpowered or just build for insanely high rpm. Any great resource for that kind of stuff?

@Sascha I don't really know how to read German but this motor is about 20 euros and ships free to Germany... but max 80 RPM and too much voltage for the driver. I just listed that as a reference; you might need a bigger driver.

What I am unsure of at the moment is how a geared DC motor would behave if used with lower input voltage or PWM to rotate slower than the rated speed. See for example: http://www.ebay.com/itm/12V-DC-300-RPM-High-Torque-Gear-Box-Electric-Motor-NEW-/220817730384?pt=LH_DefaultDomain_0&hash=item3369c32b50

If you need to rotate huge loads, a permanent magnet coupled to the axis of a brushless DC motor, driven by an electronic speed controller (used for model aircrafts, multicopters, etc.) could be an option. This is the mechanical principle used in standard magnetic stirrers used in the lab, particularly when the stirrer has an additional heating.
Small (and flat) magnetic stirrers without heating, similar to the one in your image, however often have no (rotating) mechanical parts at all, but use a set of coils periodically powered in sequence. Here, the only mechanically rotating part is the stirring bar itself. A commerically available model would be this one.


text:
How can a 5v Uno talk to a 3.3v Due?
I currently have an Uno (which operates at 5v), and I'm looking at buying a Due (which only operates at 3.3v). I'd like to make them communicate via Serial or SPI or similar, but presumably connecting them directly isn't an option (I guess the Due's pins would get damaged).
Is there any way to make the connection safe? Or is there an alternative form of communication I could safely use between them instead?

For a 5V logic output to a 3V3 logic input, you can use a resistive divider to lower the voltage.
When unloaded, a 3V3 logic output is just enough to drive a 5V logic input. Check the AVR datasheet for the exact voltages (0.6 × Vcc = 3V, found under DC Characteristics in the datasheet).

In other words, with a little bit of special care it may just work.
To construct a more reliable and bidirectional solution, use a level shifter. There are several listed on this page but other manufacturers make similar devices.
This document describes how a MOSFET can be used to bidirectionally convert logic levels between different supply voltages.

+1 for the MOSFET solution reference. I didn't think bidirectional level-shifting could work. Fascinating.

To add, for the MOSFET level converter there is no need for discrete components - there are devices like the FDC6301N dual FET. Or there are dedicated level shifters like the PCA9306.

Adafruit has a ready-to-go MOSFET level shifter (http://www.adafruit.com/products/757) that also plays nice for I2C communication, where you need to have bi-directional level translation.


text:
Circuit diagram interpretation and electrical flow

I'm new to Arduino and consequently, to circuits. I've been reading Arduino Robotics by Warren and this was a circuit present in the book.
From what Warren has said, electricity in the circuit travels from the negative pole to the positive, BUT to imagine it as going the other way for simplicity. So, looking at this circuit... it seems useless to have the resistor placed after the LED, based on the + --> - model. Wouldn't the LED turn on before going through the resistor, rendering the resistor useless?
Sorry if this seems like a basic concept, I'm entirely new to this.

So, this seems only very tangentially related to Arduino, being a beginner level electronics question. Should it be here?

The OP got this question after reading Arduino-related stuff, so Arduino.SE is a natural target, although I agree this question would probably better in EE.SE

@jfpoilpret Indeed it belongs in EE.SE. Actually, it's already there, so there's no point in migrating, in case anyone is thinking about that.

Should the Resistor be Placed Before or After the LED?
The important thing to remember is that the direct current electricity must flow through the circuit to be useful. Since the resistor is part of the circuit (meaning that there isn't another path for the current to take) it resists the overall flow, thereby helping to protect the LED. Whether before or after the LED, it would still be in the circuit, and would therefore still reduce current flow.
Visualizing the Flow of Water
Think of it like a water hose, where the LED is a flow meter and the resistor is your foot. If you step on the hose before the flow meter it will cause the overall flow to slow down. Stepping on the hose after the flow meter but before the nozzle will have the same result, as the water must pass through the entire length of the hose before being released.


text:
How do I use a i2c port expander to read buttons with pull ups and inverting the resulting uint16_t?
I am using a mcp23017 to read button presses for my joystick project and am using the internal pullup to minimize complications. Is there a way to invert all the bits in the uint16_t so i can send the values as normally off?
I'm using this Adafruit library.
And the reading code: uint16_t buttons = mcp.readGPIOAB();

The inversion operator in C++ is ~.
Serial.print(buttons, BIN);
Serial.print(~buttons, BIN);

Amazing dude thanks!!! I added a ~ in front of mcp.digitalReadGPIOAB(); and that has done the trick.

Welcome to Arduino! You can click the "accept" button (the green checkmark by the answer) to mark that this solution worked. Thanks! :)


text:
Can't send serial data throught serial pins but it works with the usb port
I am just starting out a project and I am having a little bit of trouble. I want to send data collected from an IR distance sensor, and send it with an XBee Pro S2B to my computer so I can do other stuff with it. The code I am using right now is pretty simple:
void setup()
{
  Serial.begin(9600);
}
void loop(){
 int distance = analogRead(0);
  Serial.println(distance);
  delay(1000);
}

The problem I am having is that when I turn on the arduino with batteries and disconnect the usb cable, the tx light stops turning on and no serial data is sended, AND if I connect it to the computer via USB again it won't work anyway, only works right when I upload the code. The XBees are configured correctly, I have done the chat example on the Building Wireless Sensor Networks by Robert Faludy.
Is it some code error? I must be really obvious.
By the way, when I upload the code and the serial data is sended throught usb, the data displayed on Arduino IDE's console is correct, so the sensor is wired correctly.
I am using an Arduino UNO and I have the XBee's and arduino's drivers installed correctly, and for the XBee I am using the XBee Explorer from Sparkfun

TX/RX LEDs do not blink when used on external power.

Upvoted, I am having the same issue. This is not a noob problem either. The bare Arduino Uno serial is not working when powered from a 12V bench supply from Vin when USB is not plugged in.

I suggest you try to flash the pin 13 LED in your loop().  It seems like the Arduino is not booting correctly on the batteries?
The serial port on the uno is kinda messy, it shouldn't really be shared with the usb port like that.  I prefer the Leonardo for these applications - where the USB serial and serial pins are totally independent.

The usb isn't intended to be used, only the pins, but only works when I upload the code and I haven't disconnected the cable. I am going to try that, will edit with the results

I just programmed it with a led flashing every second, and it works if I have the XBee disconnected, but once I plug the xbee the led starts flashing radomly very fast and no serial data is sent. I think is worth noting I am using the build-in led. Maybe it's because I am using the 5v output from the arduino to power the sensor AND the 3v3 for the XBee?

What batteries are you using?  It sounds like the Xbee is drawing too much power - you might need to move to bigger batteries.  Another way of testing would be to power the Arduino with a plug pack on the barrel connector (saves batteries until you're ready to go mobile).

I guess you're dropping down the 5V to make the 3.3v using a regulator?

"The serial port on the uno is kinda messy, it shouldn't really be shared with the usb port like that." this is a comment on the electrical design of the Arduino, not on how you are using it.

I am using 4 standard AA non-rechargeable 1.5v batteries, with a barrel jack conector. And for the sensor I am using the 5v output on the power section of the pins and for the xbee I am using the 3v3 output. This may be the most .... question ever, but those pins are outputs right? I have always thought so and I thought that the arduino had another regulator for the 3v3 output. I just tried disconnecting the XBee from the 3v3 output and the LED worked correctly, no idea of the serial data but the TX led isn't lighting up

This is the beauty of open hardware, we have the schematic - http://arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf  The 3.3v pin using an LM2985 regulator that can only supply 150mA, I don't think it is powerful enough for an xbee.  From http://www.digi.com/products/wireless-wired-embedded-solutions/zigbee-rf-modules/zigbee-mesh-module/xbee-zb-module the pro need 205mA, you should switch to the ZB, it needs only 40mA (or add a separate 3.3v power supply).  Until you sort out the power, the system won't behave predictably.

So I guess what I can split the output from the battery pack and use one part to power the arduino and the sensor and the other part to a 3v3 regulator with larger output? Or would I have another problem? Would I need to have 2 battery packs?

@TomKeddie the 3.3 regulator is sufficient alone, as I've seen it used several times on the Arduino Uno without any external regulators. Also, the Uno's serial port isn't messy at all. The Leonardo has two: one directly connected to the computer and the other one connected to pins 0/1, where the Uno has the computer also connected to 0/1. You can only use the pins OR the computer at a time. That's not "messy," just a limitation.

@"Annonomus Penguin"  With an xbee pro, the math above is fairly clear.  "Also, the Uno's serial port isn't messy at all."  You drive one input with two outputs (RX from ATMEGA and RX from shield) that is indeed messy, but it is not the issue here.

"So I guess what I can split the output from the battery pack and use one part to power the arduino and the sensor and the other part to a 3v3 regulator with larger output?"  I think so unfortunately (unless you can drop to the lower power xbee).  Do you have a 3.3V source you can use to power the Xbee temporarily to verify this is the problem?

Try interchanging the Tx-Rx pins of your XBee-Arduino connection.
Since you are getting correct values on the Arduino IDE, this means that both sensor and serial is working, but it sends values only when connected via USB which means that problem lies in your link between Arduino-Serial Device (in this case XBee)

You have an XBee shield on top of the Arduino UNO?
Do you have an XBee attached to the computer?
Can you describe your setup a little more.
The TX Led on the Arduino is only on the USB side, and doesn't signify TX on the XBee. The XBee itself should/could have a TX/RX leds itself. Check the Arduino schematic to confirm this.
How are you reading the Serial on the computer? Thru the Arduino serial monitor? That won't work for the XBee. You'll need another Serial monitor for the XBee attached to the computer. ie, Arduino with XBee shield. Then an XBee connected via some breakout board to the computer. The Arduino Serial monitor won't see the XBee (use hyperterm on windows or some serial port monitor on other systems).
Also, check your switch on the XBee (if you have one), most redirect the USB/Serial connection between computer/Arduino and Arduino/XBee. It's one or the other not both.

I am sorry for not clarifying a bit more in the initial question, I thought this was something simple. I am not using a shield, only a XBee explorer with pins soldered to it, and I am reading the output with CoolTerm. And I didn't know that about the TX light only working for USB... So: XBee connected to arduino via an XBee explorer with pins soldered, and the receiving XBee connected to the computer via USB using another XBee explorer. Coolterm is configured correctly, I know that because I have used the xbee to do a chat between 2 computers, and the XBees themselves are configured correctly.

Finally found out how to get the Arduino Uno serial port to work without a USB cable! I used a scope to see what was going on and found that using an external power supply on the Arduino power port only showed +3.3 volts on the +5 line. I pulled the plug on the external power supply and put a regulated +5 VDC on the +5 VDC pin.  Now, both software serial and the UART ports work fine - hope this helps!

Ok, I have verified this behavior with a bare Uno on an external power supply driven from Vin.
The serial is outputting, but because of the way the TX and RX LEDs are wired in the Uno, they do not activate unless the USB processor is active.
This is super dumb and super confusing, but you can clearly see it's wired up this way:

I have confirmed that serial data is coming out of the Arduino with a logic analyzer, but the LEDs do not light up.

It's not super dumb. Putting an LED and its resistor on a couple of pins would alter the behaviour of those pins if they were used for something else (eg. input). On the earlier Arduino Unos they had an LED on pin 13, now it is driven by an op-amp to try to reduce this problem.

Yes, I think I would advocate for a dual comparator, or even a couple of transistors on the lines! I suppose it could be an already-fixed firmware problem with the Uno, but I haven't had time to get the DFU tools to find out.

And yes, by oversight or design, I maintain that the Tx and Rx LEDs not lighting is "super dumb and confusing"


text:
RS-485 with Arduino
I have two Arduinos on a RS-485 line, one acting as a Master and the other as a Slave.  The Master simply transmits information to the Slave, which parses it.
They work fine when the Master is turned on first and then the Slave is turned on.  However, I'd like to  make it so that the Slave can be disconnected and reconnected to the line and re-discover the connection (ideally without resetting either Arduino).
Here's the code from the Slave's loop
  void loop()
     {

       if (RS485Serial.available() >0 )  //Look for data from other Arduino
       {
        char byteSend = RS485Serial.read();    // Read received byte
        String str = String(byteSend);
         if (str == "<")  {      //  beginning of the transmission
       // does stuff here
      }
   }

}
Here is the relevant section of Master's loop:
  output_value ="<1,1,1,1,1,1,1>";
 RS485Serial.print(output_value);
 delay(250);
 RS485Serial.flush();

Any advice is appreciated...

What is the problem ? Have you already tested without success?

@bluefeet - this is not an Arduino question.  It is a protocol question which happens to be implemented on Arduinos, but what is important is the protocol, not the platform, and dumping it to the Arduino site merely disconnects it from other similar issues that don't happen to use that platform.

@ChrisStratton: I agree, but I wish you would say which site you think is better for protocol questions like this one.

    char byteSend = RS485Serial.read();    // Read received byte
    String str = String(byteSend);
     if (str == "<")  {      //  beginning of the transmission
   // does stuff here
  }

This is an extremely inefficient way of testing for one character. Much better would be:
    char byteSend = RS485Serial.read();    // Read received byte
    if (byteSend == '<')  {      //  beginning of the transmission
   // does stuff here
  }

However, I'd like to make it so that the Slave can be disconnected and reconnected to the line and re-discover the connection (ideally without resetting either Arduino).

I know I'm not supposed to ask questions here, but what is stopping you?


text:
Erratic behaviour using Serial.print() when powering only from power supply
I'm using an arduino uno with a thermal printer and the following code:
#include "Adafruit_Thermal.h"
#include "skull.h"
#include "SoftwareSerial.h"
int printer_TX_Pin = 8;  // This is the yellow wire
int printer_RX_Pin = 9;  // This is the green wire
Adafruit_Thermal printer(printer_RX_Pin, printer_TX_Pin);

void setupPrinter() {
  printer.begin();
};

void doPrint(char* output) {
  Serial.print("Will print: ");
  Serial.print(output);
  Serial.print("\n");
  printer.println(output);
  printer.feed(2);
}

void setup() {
  setupPrinter();
  doPrint("This is a test to see if it will print only from power supply");
}

void loop() {
}

That code works fine if the arduino and printer are plugged into 5v and the arduino is also plugged in to a computer with USB. Once I remove the USB cable it starts printing:
This is a test to see if it will
This is a test to see if it will
This is a test to see if it will
This is a test to see if it will
This is a test to see if it will

over and over infinitely. In other programs it prints a slightly garbled first line then stops. When I remove the serial.print lines, this doesn't occur. Why would that be?

Are you using a standard Arduino board? E.g. the Arduino Uno?

Yes, it is an arduino uno

It seems likely that your Arduino is repeatedly resetting, which means it's starting the program again from the beginning all the time. This can be caused by insufficient power.
For the standard 5v Arduino boards, the minimum recommended voltage for an external power supply is usually 7v. An on-board regulator brings it down to 5v.
Technically, you can run them directly from an external 5v supply. However, you have to ensure that it's properly regulated, and that you bypass the on-board regulator.
Obviously you also have to ensure your external supply is capable of sourcing sufficient current. If you're just running an Arduino and a small thermal printer then it's probably OK, but it's certainly worth checking.

I'm using a 5v 4amp power supply with the arduino, neopixels and the printer powered directly from it and then a PIR sensor and adafruit musicmaker shield + 3w 4ohm speaker powered from the arduino. The printers maximum current draw is 1.5 amps. Should I use a 7v supply in this case?
I have a program that runs the lights and sound and then resets only when it gets to the printing part. I suppose it could be when the printer runs this causes a problem with the power causing it to reset?
Why would having the USB help though? I thought that the usb power was bypassed when using DC power.

@Tom - A supply of 7-12V would be a good idea. It will be falling-back on the USB power when possible because your DC supply is too low.