Choosing a development board for your projects can be a daunting task. Given the large number of development boards available today, it’s no wonder.
For those who don’t already know this, let’s first come up with a definition for development board.
A development board is a small circuit board containing either a microcontroller, microprocessor (or both) which supplies the necessary components and software for design and programming.
Most of us are familiar with boards like the various incarnations of Arduino, Raspberry Pi, and even BeagleBone. These are some of the most popular options among hobbyists and makers.
Some of us are familiar with other, lesser known boards like Intel’s Galileo or Texas Instrument’s TI LaunchPad.
Make: Magazine’s recently released 2018 Super Duper Board Guide covers 74 different development boards and their specs. That’s a lot of boards and there are even more that Make didn’t cover.
And, using stand-alone (naked) microcontrollers is still an option, though usually more challenging than using a development board. However, this article focuses on development boards.
Of course, covering even a small percentage of all the boards available in detail would take up many blog posts and is beyond the scope of this article. Rather, the goal is to guide you toward which option would be best for your project considering things like specs, type of board, price, and project requirements.
For example, when choosing a board consider if it contains all the components and power to run all the features you require. An over-kill can be wasteful and just as bad as picking a board that lacks the power and specs you need.
The first thing to consider when choosing a development board for your project is the type of board.
Development boards fall into one of several different categories depending on its specs and strengths.
There’s the microcontroller boards, which include the Arduino Uno and Mega. Also included in this lot are boards made by Adafruit and SparkFun, among many others.
Then there’s the single board computers like the RPi and the BeagleBone Black. Even Samsung has their own single board computer. In fact, some computer hardware vendors like Realtek, Qualcomm, and Nvidia are on the development board wagon with their microcontroller boards and single board computers.
Last but not least are the powerful and versatile field-programmable gate array (FPGA) boards. Some of you may not be familiar with FPGAs, but they’re definitely worth learning about. Maybe we’ll talk about FPGAs in a future post.
Your project type (i.e. control, visual, sensing the environment, etc.) should dictate which of the above three is appropriate. Sometimes, you may use boards from more than one of the three categories, like pairing an Arduino Uno with a Raspberry Pi.
Your programming language or operating system of choice should be another important factor in choosing a development board.
Support for multiple operating systems, programming languages, and integrated development environments (IDEs) can create a richer experience and a more appealing board.
Some boards, like the ubiquitous Arduino, sport custom IDEs which provide a ton of libraries and other features to make using their platform easier.
C and C++ are universal languages (which you can learn about in my C tutorials; start with C Tutorial 1 if interested) and many boards support them or some similar variant.
And if you’re familiar with the Arduino IDE, there are many microcontroller boards not made by Arduino that use the IDE.
IDEs for some boards will allow you to explore more than one programming language.
Most single board computers run some flavor of Linux. For example, the most popular operating system for the Raspberry Pi is Raspbian which is based on Debian Linux.
A few single board computers will allow you to choose between Linux, Android, or even Windows 10 IoT. For example, the BeagleBone Black will let you use Linux or Android, though it comes with Debian out of the box.
Windows 10 IoT is a special version with an emphasis on Internet of Things applications. According to Microsoft, it is optimized for smaller devices with or without a display that run on both ARM and x86/x64 devices.
The situation is similar with single board computers and programming languages. Many boards, like the RPi will allow you to use Python (the most popular language for RPi), C, C++, Java and more.
Community and support are important factors when choosing a development board.
Let’s talk community first.
Of course, the more popular boards like the Arduino and Raspberry Pi have bigger communities, social media groups, and websites devoted to them.
The resources a community can provide can prove invaluable. Such resources include schematics, source code, tutorials, parts, and solutions to problems.
Some of the lesser known boards still have communities associated with them. These communities tend to be smaller but can also be more tight-knit than large communities with 100,000+ people.
Most boards have options for expansion and additional functions. Shields, hats, capes etc. usually provide these functions. We’ll just call them all shields from here on, since the concept is essentially the same. Just as before, the more popular boards tend to have more shields available, though there are shields which address common needs for the less popular boards.
Of course, one could create their own version of just about any shield, but this would require more work and could be a steep learning curve. On the plus side, doing so may reward you with a gain in knowledge and a savings in money. It can also offer more flexibility to tailor the hardware specific to your own needs than out-of-the-box shields.
Your project requirements will determine the specifications of your development board of choice.
Bigger with more bells and whistles isn’t always better. One reason for this is price, as boards with beefier specs tend to cost more. Another reason is that more bells and whistles can mean more problems.
I’ve already alluded to the fact that you should neither go with an over-kill or an under-kill for your project. Something in between is best. Of course, if you plan to add more functionality down the road better specs may not be a bad idea, within reason of course.
Let’s go over some key specs one by one. If you’re familiar with how computers work and their architecture, you’ll recognize many of these specs.
You may already know that this variable affects the speed and over all performance of the board.
Beware of comparing clock speeds between different CPU/microcontroller families though. Other factors like instruction cycles (and clocks per cycle), amount of cache (if any), instruction sets, pipelining and more can make this difficult. And they can also have a significant impact on the performance of the processor or micro.
Those who have added more RAM to their desktop or laptop computer know the virtues of doing so. Though you can’t usually add memory to a development board, it may be worth springing for a board with more RAM, if your project calls for it.
The more memory, the faster the board will be. Memory impacts the speed at which data processes and it affects the number of tasks that can run simultaneously.
Choosing a development board with better graphics will allow the board to process video without bogging it down so much. It may also be handy to have video outputs like HDMI or VGA.
If your project involves machine vision, facial recognition, gaming, or the use of a complex display (i.e. a large, full color LCD touch screen) opting for a development board with better graphics isn’t a bad idea.
GPIO pins allow you to connect things to your development board. The more pins, the more simultaneous connections you’ll have. You’ll use these to connect sensors, LEDs, LCD displays and more.
Some GPIO pins have specific functions like UART, I2C, SPI, etc.
If you need to connect a lot of things to your board, you’ll need more general purpose I/O.
Choose a development board that has enough storage for things like operating systems, programs, and data for your purposes. Depending on your use, you may need only a little or a lot.
Analog-in pins are necessary for acquiring data from analog sources, which is pretty much anything in real life. Things like temperature, humidity and much more are all analog values.
The analog pins often connect to an analog to digital converter (ADC). ADCs are specified by their resolution, among other factors. Resolution refers to the number of discrete levels which the input signal can be “chopped up” into.
For example, the Arduino Uno’s 10-bit ADC has 1024 different levels (0-1023) because 210 is 1024. So, if I have a 5 V signal, the smallest “piece” I can cut it into is 5 divided by 1024 or about 5 mV. Read this for more about analog vs digital. If you need really precise measurements, you’ll need a development board containing an ADC with a higher resolution.
Sampling rate, or the number of data points the board can measure in a given time, is another important specification.
This comes in handy for things like driving servo motors. To do so, PWM varies the duty cycle (on time) of a square wave. Just like analog inputs, PWM inputs are characterized by resolution and sampling rate.
This is an important but sometimes overlooked spec. It plays a major role in choosing a development board, especially if you plan on using batteries to power your projects or experiments.
One must also consider how often they would need to change the battery. It’s a lot easier to change a battery that powers a gadget that sits on your desk than it is to change the battery of a gadget hanging from a tree in the middle of winter.
Many developments boards offer lower-power options. For example, some boards can go to sleep when not in use or even enter a very low-power mode. This can significantly extend the life of a battery.
Some of your projects may plug into the AC power in your home. Since you pay for electricity, power consumption can still be an important spec to consider.
Finally, price can be a factor, especially if you’re on a tight budget.
The prices for the 74 development boards recently featured in Make: Magazine range from four or five dollars on the low end to $270 on the super-high end.
While we didn’t really talk too much about them, the featured FPGA boards range from $95 to $195. FPGAs are really cool chips, and I encourage you to experiment with them if your budget allows.
Remember that regardless of your budget, the main objective should be to get a development board that is suited to your project. So, depending on what you’re doing, you may want to opt for a less pricey board.
As we now know, there are hundreds of development boards to choose from.
Of course, some are more popular than others and we know that our choice depends on the demands of our project. We also know that we should possibly consider future upgrades or expansion when choosing a development board.
Let’s do a quick overview of three popular boards and what they may be good for. While there isn’t enough room here to cover them, I also encourage you to explore other boards.
The Arduino Uno is useful for simple, light weight programs. It’s a go-to for things like temperature recording, LCD control, motor control, robotics, and even security systems. And the price isn’t bad — I’ve seen them as low as $19 on Amazon.
The Raspberry Pi 3 model B is partially open-source. It’s a powerful development board which can run Linux, Android or Windows 10 IoT. It shines for media applications due to it’s Wi-Fi, HDMI, and Ethernet interfaces. Consider using it for security systems that employ cameras, media servers, quadcopters and more complex robots.
Finally, let’s talk about the BeagleBone Black.
Partially open-source, this board boasts simple set up with Linux already installed. It also has 66 GPIO pins, allowing you to connect an array of gadgets and sensors. However, it’s a bit pricey at about $55 though not the most expensive development board available. Use it for Cloud computing, complex robots like hexapods, CAN and automotive projects, and more.
This blog has a fair amount of posts about the Arduino, but perhaps future articles will go into more detail on some of the other development boards available.
Until then, comment and tell us what your go-to board is!
Pin
4
121
Shares
Hey guys,
I'm thinking of buying a discovery board or evaluation board. However I'm not sure which one to choose.
I'm currently working on an Arduino for a private project, but arduino has 2 Major disadvantages:
1) no Debugging ability
2) very small SRAM
At my work place, we are using STM32 MCUs and they work pretty well, so that's how I stumbled upon the STM32 discovery boards/eval boards.
I have some simple ''must haves'' in my Project.
I'd like to run freeRTOS on my MCU, so the processor should have enough Memory.
I'd like to have (eclipse) Debugging ability.
And I'd like to connect my board to a PC via USB, so the MCU should Support USB slave functionality.
Could you give me some suggetions on what boards to use?