Microcontrollers on Bald Engineer

Standalone Arduino Turn-On and Debug

Mon, 09 Jul 2018 13:00:54 +0000

This AddOhms episode is part 3 of the “design your own Arduino” series. In this one I populate a bare PCB, reflow solder it, debug a few issues, and load the Uno bootloader. Originally, I designed 2 versions of the board. One version contained an error that I planned to fix in the episode. Well, turns out, the “correct” board had two issues which were more interesting. Check out the #27 show notes for links to a bunch of stuff in the episode, including the design files.

Watch this video on YouTube

Learn Six Oscilloscope Measurements with an Arduino DUT

Wed, 13 Jun 2018 18:44:22 +0000

One of the best ways to learn how to use a new piece of test equipment is to use it. Sounds easy, right? The problem is, sometimes when you are in the middle of troubleshooting your circuit, figuring out what the knobs on your scope do is an immense frustration. Use these 6 oscilloscope measurements, and just an Arduino Uno, to learn how to use a new or unfamiliar digital scope.

5 Common Arduino Programming Mistakes

Wed, 17 Aug 2016 13:39:41 +0000

Whenever someone sends me some code that doesn’t work, there are a few common Arduino programming mistakes that I check. Some of these mistakes I make myself. In most cases my code will compile just fine. Sometimes, these mistakes won’t generate any compiler error. When my Arduino code is acting up, these are the first things I check. Here are my 5 common Arduino programming mistakes, I use to debug non-working code.

Arduino Bootloader, What is it?

Wed, 15 Jun 2016 13:00:14 +0000

Almost all microcontroller (and microprocessor) development systems use some form of a bootloader. Often called firmware, mistakenly, the Arduino bootloader is one example. Since it is a rather popular platform, let’s use it as an example. Let’s talk about what a bootloader does and how it works. When a microcontroller turns on, it only knows how to do one thing. Typically, that one thing is to run an instruction found at a specific memory location. Often this location address 0x0000, but not always. Usually, this memory location will contain a jump instruction to another place in memory, which is the start of the user program. The bootloader, however, exists in a slightly separate memory space from the user program.

Proper Larson Scanner with Software PWM (Repost)

Wed, 21 Oct 2015 16:00:03 +0000

Last week I had a detailed Arduino tutorial on software pulse width modulation using millis() and micros(). Why? Because I wanted to create a Proper Larson Scanner, with persistence and at least 8 LEDs. KITT larson scanner example Even though it is a popular project for the Arduino Uno, most Larson scanner tutorials, like my first one, have a few flaws. First, there is no persistence, or tail, to the LED as it moves back and forth. Persistence could be solved by using pulse-width-modulation. The Uno and other 328p-based micros only have 6 Pulse Width Modulation (PWM) pins. And let’s be honest, every project is made better by adding more LEDs. :)

Space Invaders on Gecko EFM32

Fri, 16 Jan 2015 15:05:08 +0000

The Gecko Zero EFM32 Weather Station Evaluation Board from Silicon Labs is intended to show off the low-energy or energy harvesting capabilities of the EFM32 Zero. The ARM-based board has physical and cap sensitive buttons along with the LCD. It comes pre-loaded with a demo program, which is the classic Space Invaders. If you’re interested in more about the board, I wrote a road test of Gecko EFM32 on element 14. (Spoilers: I wasn’t impressed. Not a bad board, but rough development environment.)

Watch this video on YouTube

Installing Arduino Library from GitHub

Wed, 07 Jan 2015 14:45:58 +0000

What happens when you have a random chip or sensor you want to interface with an Arduino, but don’t know how? You search for a pre-existing library of course. And where are many libraries hosted and available from? A place where eager developers hack together code, post updates, and collaborate with others: Github! tldr; If you’re having trouble installing a library, look directly at Step 3. Installing a library Many Arduino libraries are available from GitHub. It really fosters the spirit of Open Source work. If you come across a library you need on GitHub, getting it into the Arduino IDE is relatively simple. However, if you’re new to GitHub (or the Arduino IDE) you might miss the simple steps.

Well formatted Arduino code in one click

Fri, 16 May 2014 15:00:06 +0000

Warning, the title of this post is a little bit misleading. It isn’t just one-click to get cleanly formatted code, it’s actually two. There are two things seasoned programmers will tell new programmers, that they don’t understand (at first): Always comment your code Properly indent code The problem? As a new programmer, you might not know how to do #2 until you get some experience. How indenting helps The reason you indent code is to make it easier for a reader to understand the code’s flow. A compiler (well except in Python) doesn’t care if two lines line up or not. T he recent issues around Apple’s “goto fail;” are a great example of how indentation is meaningless to a C compiler.

Teach your Arduino to listen with µSpeech

Tue, 08 Apr 2014 15:00:11 +0000

When most people say “Arduino” they mean an ATmega328 based board like the Uno. This means a simple 8-bit microcontroller with only 2K of RAM. That’s 2,048 bytes of memory to work with. So when someone asked me if the Arduino could do speech recognition, to be honest, I laughed. Then my jaw dropped when I saw µSpeech. A speech recognition library for the Arduino Uno’s ATmega328. The algorithm used is sophisticated and results will vary based on the types of words used as well as the hardware. It uses only 160 bytes of RAM.

Arduino: Assignments != Comparisons

Thu, 03 Apr 2014 15:00:59 +0000

There is one mistake that all C programmers make, regardless of experience. You’ll do it often when you get started, but never completely stop. The mistake? Confusing the “assignment” operator with the “comparison” operator. Take a look at this line of code: if (something = 0) { Notice the problem? If not, then you might fall into this common trap. The most annoying part? A C-Compiler won’t give an error. That code is legal C. Legal code doesn’t mean you’ll get the results you expect. In fact, this is probably not even close to what you wanted. This simple mistake and why it “works” is explained below.

When do you use the Arduino's Serial.flush()?

Thu, 02 Jan 2014 12:00:47 +0000

In the Arduino library, the Serial object has a method called “flush().” Often users go throwing it into programs without fully understanding what it does. It doesn’t help that it’s functionality changed when version 1.0 of the Arduino IDE was released. Does Serial.flush() affect the Transmit Buffer or the Receive Buffer and when do you need to use it? What does Serial.flush() do? From the Arduino reference for Serial.flush (found on this page):

5 Myths Everyone Believes about Arduino (that aren't true)

Wed, 01 Jan 2014 12:00:59 +0000

Having spent the past 6 years writing code for the Arduino platform, I’ve noticed a trend in myths from both newcomers and veteran users. Here are the Top 5 Myths I see come up on forums, in classes, and on IRC. 1. The Arduino uses its own Language This myth isn’t helped by the Arduino.cc home page used to say “T he microcontroller on the board is programmed using the Arduino programming language.”

AddOhms #7 - Comparing Arduino and Raspberry Pi

Mon, 16 Dec 2013 12:00:59 +0000

The seventh AddOhms TutorialCast has gone “live”. (Gone “uploaded” sounds wrong.) Being able to understand difference between an Arduino and a Pi is a critical point for many new electronics hobbyist. The boards seem so similar, but they are so different. AddOhms #7: Comparing the Arduino and Raspberry Pi Full Episode Notes are available on the Episode’s homepage.

Arduino: De-Bounce a Button with micros() or millis()

Fri, 13 Dec 2013 12:25:45 +0000

The Arduino is fast, humans are slow. When you push down a button, what seems like a single change to slow humans is really multiple presses to an Arduino. This is known as “bouncing.” Figure 1 is an oscilloscope screenshot showing what could happen when a button is pressed. Figure 1 - All the bouncing! The top trace shows the high-low-high transition of the button press. But notice all of the activity at the start of the high-to-low transition. The bottom trace is a “zoomed-in” view of that area. The button is actually transitioning multiple times before staying low. Internally the contacts are “bouncing.” This could result in false reads. In software, we can ignore these bounces by waiting some period of time after the first transition.

Arduino: Chasing LEDs with millis()

Thu, 12 Dec 2013 12:00:34 +0000

A popular LED project is the “Larson Scanner.” This scanner emulates the effect seen on KIT from Knight Rider and the Cylons in Battlestar Galactica. The code is usually written using “delay()” which means you can’t combine it with anything else. The following code could be put into a function, called periodically and allow your code to scan while doing other things. One thing to note, a proper Larson Scanner has some persistence to the next and previous LEDs, this code does not. Maybe that would be a good exercise for the reader?

Arduino: Timing Code with Millis() as a Stopwatch

Wed, 11 Dec 2013 12:25:22 +0000

Since most Arduino boards do not have debug capability, this limits the programmer to using Serial.prints. A useful piece of information might be knowing how long certain parts of code are running. Here’s a simple example that demonstrations: How to properly use Serial.flush() (hint: it’s for TRANSMIT, not RECEIVE!) How long Serial.print()s can “tie up” the Arduino. At 9600 baud, you’ll see that the Arduino is only busy for about 20 milliseconds in the first chunk of code, but busy for 93 milliseconds in the next. That’s because the Arduino (since 1.0) started using a transmit-buffer. Did you know your code doesn’t wait for a Serial.print to finish?

Arduino: Independent On-Off Times with Millis()

Tue, 10 Dec 2013 12:25:29 +0000

When using delay() to flash a LED there is a time for the LED to be on and then off. This makes it easy to have independent control of the “on” and “off” times. The standard blink without delay example doesn’t give you this flexibility. millis-cookbook-two-duty-cycles This example code gives you complete independent control of how long a LED (or any OUTPUT pin) stays “ON” or “OFF”. This also demonstrates a very simple two-state state machine.

Arduino Millis() Examples

Mon, 09 Dec 2013 23:00:51 +0000

You’ve recently learned about millis() and can’t way to delete all of your references to delay(). The problem is that you don’t know quite how to convert your code into millis()-compatible code. Here is a (running) list of millis() examples I’ve put together to help. Baldengineer’s Arduino millis() Examples Arduino Multitasking - Step by step examples of how to convert delay() code into millis() based code, to simulate multitasking. Police Lights - Flash two LEDs like strobing police lights Control ON and OFF time for a flashing LED. - More control than “blink without delay” Stopwatch Example - Calculate how much time code takes to execute Chasing LEDs - Larson-scanner style chasing pattern De-bounch a button (or switch) - No need for de-bouncing capacitor Delayed events after a button push - Timed events (button push is just example.) analogWrite() PWM Fading - No delay() and a simple function to keep a LED fading with PWM Detect Short and Long Button Press - Give one button multiple functions You might also want to check out my “Blink Without Delay - Line by Line Tutorial.” It is a much more in-depth explanation than the comments provided with the Arduino IDE example.

The hidden Arduino Macro F() fixes random lock ups

Wed, 20 Nov 2013 12:25:33 +0000

It’s 3am but you are not going to bed until you squash this last bug. You sprinkle Serial.print() statements everywhere you can think of, and then that’s when all hell breaks loose: Your code randomly locks up, the LEDs go crazy, and you’ve had it. What’s going on? You’ve run out of RAM! All of those Serial.print() statements are composed of c-style strings. Which are “constant character arrays.” In order for those arrays to work properly, they get loaded into the ATmega’s RAM before your code starts running. Which can be a problem because 2,048 bytes of RAM doesn’t allow for much.

Three Alternatives to Arduino's Serial Monitor

Tue, 19 Nov 2013 11:39:29 +0000

The Arduino IDE includes a “Serial Monitor” which is decent for basic serial communication. However, when you need real time serial interaction or data logging capabilities, that’s when one of these serial monitor alternatives can come in handy. putty [Windows] Download: PuTTY. License: MIT. Hands-down one of my favorite terminal applications for Windows is PuTTY from Simon Tatham. In addition to being a great serial terminal it can also handle telnet, ssh, and a host of other things (no pun intended). The source is available and looks like it runs on UNIX platforms, but I have never tried. If you’re using Windows, this is probably your best go-to terminal application. Every Windows machine I use gets PuTTY in the Start Menu shortcuts.

Const vs #define - When do you use them and why?

Thu, 14 Nov 2013 11:13:40 +0000

Arduino boards have microcontrollers with notoriously small amounts of RAM. The Uno only has 2,048 bytes of static RAM available for your program to store variables. So when you need to keep non-changing variables out of RAM which is best to use const or #define? What is #define #define is often misunderstood because it isn’t a programming statement. Instead, it sets up a macro which causes a text replace to occur before code is compiled. For example in this code:

Arduino pinMode(): When to use and why

Mon, 11 Nov 2013 11:57:39 +0000

All Arduino boards have GPIO pins with digital and analog capabilities. The Arduino pinMode() function determines how the pins will operate. A surprise might be that in some cases it is not necessary to use it. And when you do, pinMode() may not always work the way you expect. This post outlines how the Arduino pinMode() function works and when you should (or not should) use it. pinMode(13, OUTPUT); Arduino pinMode() scope This post focuses on the 8-bit AVR Arduino boards such as the Uno, Mega, and Leonardo. The processors on these boards are the ATmega328, ATmega2560, and ATmega32u4, in that order. For the most part, this information does apply to non-AVR and 32-bit Arduino variants. When in doubt, double check with the Arduino Reference pages for details to specific platforms.

Sawtooth waveform with the Arduino Due's Built-In DAC

Fri, 08 Feb 2013 00:36:18 +0000

Users of the ATmega328 based Arduino boards will recognize that the analogWrite() function doesn’t actually do anything analog. It just sets the duty cycle of a pulse width modulated (PWM) signal. The (new) Arduino Due board, which I have had limited time to play with, actually sports two Analog DAC channels. Using a very simple for() loop, it is possible to generate a sawtooth waveform using these channels.

First impressions of the Arduino Due

Fri, 23 Nov 2012 04:49:45 +0000

I’ve been working with Arduino boards for a number of years, as shown by the dates on some of my older blog posts. In that time I’ve only used boards based on the ATmega8 (like the Duemilanove or Uno). The Due is the first Arduino board I have used in what I would call the Mega form factor. Physical Differences I’m surprised by the size difference. I’ve always thought the original Arduino form factor was small, the Due is larger but still feels small.

Arduino: Fixing "Serial Port in Use"

Mon, 08 Oct 2012 09:46:16 +0000

Here’s a couple of quick tips to get around the Arduino IDE error message “Serial Port in Use.” These mostly apply to OSX, but since it is UNIX based, they may make sense for Linux as well. List Open Files Applies to: OSX, Linux. The check to see if another process (like a previous run of avrdude) is holding the serial port open is easy on both Linux and OSX. Just open a terminal and run the command: lsof. The command will report back all files that are currently open by the operating system. UNIX-based operating systems do everything through files, so this command is useful to see what is keeping a serial device open. Since lsof gives a list of everything that’s open, and there are a lot of “files”, use grep to only list what is relevant.

Long Overdue LaunchPad Review

Sun, 30 Sep 2012 14:13:26 +0000

Recently I realized most of my projects were all Arduino-based. There are lots of other prototyping platforms available in the market, and the TI LaunchPad, based on the MSP430 is one of them. In fact, I have had one of these boards sitting in my box of stuff ever since they came out. At $5, they because an impulse purchase when I was buying some other stuff.

Raspberry coming to a Hackerspace near you

Mon, 20 Aug 2012 09:58:51 +0000

One of the Raspberry Pi Foundation’s developers, Rob Bishop, is heading out on a Hackerspace tour in the US. Looks like he’ll be visiting a couple of spaces on the west coast, east coast, and my home town: Austin, TX. [Via raspberrypi.org Raspberry Pi Foundation US Hackspace Tour | Raspberry Pi]

Renesas Promotion Board for RL78/G13 | Renesas Electronics America

Wed, 15 Aug 2012 10:42:23 +0000

Renesas is offering a promotion version of their RL78 microcontroller. This offer is only available to their Sample Component account holders, but the process for signing up for a sample account is pretty straightforward. (There may be EAR restrictions with this board.) If you are looking for a powerful processor that is an alternative to PIC or AVR processors, this board might be worth a look. Note: It appears samplecomponents.com might have been compromised at some point in the past. Google throws a warning page up. Proceed at your own discretion.

Arduino: Getting Real Time Help

Mon, 13 Aug 2012 09:30:08 +0000

Note: The IRC Channel (along with all of Freenode) got nuked. While the Arduino Project Team provides their official Arduino forums, sometimes real-time help is just a bit better. When that is the case, I encourage you to visit the freenode.net IRC channel, #arduino. While as of today it is not an official channel, there are a number of great people available to help. You can find me under the nick “baldengineer”, big surprise, I know. Others like kline, Yoston and pwillard are also excellent people to ping with questions.

Arduino: Sending and Receiving Multi-Digit Integers

Mon, 30 Jul 2012 09:18:32 +0000

When Serial data is transmitted to an Arduino, it is sent one byte at a time. Even though you might type “123” in the Serial Monitor, that’s not quite what is sent. Instead the bytes “1” then “2” then “3” are sent. Once received into a buffer on the Arduino, these individual bytes need to be reassembled into something useful. The Arduino IDE provides Serial.readBytes() as one option. However, if you aren’t sure how many digits you are going to receive, this may not work. So another option is to use Serial.readBytesUntil() like so:

Arduino: Toggling Outputs

Mon, 23 Jul 2012 09:00:13 +0000

Did you know it is possible to toggle the state of a Arduino OUTPUT pin using a single line of code? It’s true! It’s also possible to use digitalRead() on an OUTPUT pin. Assuming pin 13 was set to output, this single line of code will cause the LED to change state (or flash) each time it is called: digitalWrite(13, !digitalRead(13)); Keep reading to understand how these two tricks work.

Arduino: How do you reset millis() ?

Mon, 16 Jul 2012 14:00:42 +0000

The quick answer to “How do you reset millis()” is: You Don’t! And here’s why: if you did, it would potentially break most libraries and functions that rely on it. Generally the reason people want to reset it, is that they are concerned about rollover. Instead of focusing on resetting millis(), here is how to use it correctly. Need to brush up on how millis() works? I’ve got a tutorial on how to effectively multi-task with millis() and another line-by-line tutorial on blink Without delay Avoiding rollover and checking how much time as passed is done in a single line: