Advanced Arduino Boards and Tools
- 9.5 hours on-demand video
- 1 article
- Full lifetime access
- Access on mobile and TV
- Certificate of Completion
Get your team access to 4,000+ top Udemy courses anytime, anywhere.Try Udemy for Business
- Select the right Arduino board for your next project
- Learn about debugging and relevant tools
- Create Internet of Things applications using Arduino and Temboo
- Use Processing to create desktop applications that interface with the Arduino
- Use OpenOCD and GDB to debug a sketch running on an Arduino Zero
- Use Atmel-ICE and Atmel Studio to program and debug Arduino sketches
- Appreciate the differences between advanced Arduino boards
- A basic working knowledge of the Arduino Uno is required.
- Having at least some of the boards and tools described in this course is optional. You can take the course first, and then decide which board to purchase for your next project
- All of the software tools presented in this course are free.
In Advanced Arduino Boards and Tools, I take you on a tour of some of the best technology that the Arduino ecosystem has to offer. This course will contain more than 8 hours of video, presented in over 50 lectures.
The Arduino Uno is awesome: rugged, easy to use, low cost, configurable, open source. But sooner or later, you will feel that it is not enough for your projects. Not enough inputs and outputs. Not enough speed. Not enough memory. Not enough communications options. The list goes on.
The Arduino ecosystem has you covered. There are more powerful alternatives to the Arduino Uno. You can leverage your existing equipment and components, and especially the time and effort investment that you have made to the Arduino, and adopt a more powerful and specialised Arduinos for your next project.
In this course, I present some of the best currently available advanced Arduino boards. I try to help you understand what is special about each one, how you can use them in your projects, and what to look out for when you migrate from the Arduino Uno.
Of course, advanced Arduino projects depend on software, as well as on hardware. Advanced projects need advanced tools! In this course, I also have this covered. Learn about advanced debugging and editing tools, cloud-based automation, and Arduino-PC collaboration.
In this course, I cover these advanced Arduino boards:
- Arduino Mega 2560
- Arduino Due
- Arduino 101
- Arduino Zero
- Arduino Galileo Gen 2
For each board, I discuss the features that distinguish them apart from other Arduino (their "special powers"). I demonstrate these features through experimentation.
I also cover these tools:
- Atmega Studio, an advanced editor and debugger
- Atmega Atmel-ICE, a debugger and programmer device
- Temboo, a cloud automation platform for the Internet of Things
- Processing, a language and framework for creating desktop applications that inter-operate with the Arduino
All demo sketches are available for download from Github, so you will not need to do much typing.
To make the most of this course, you should already have some working experience with a basic Arduino board, like the Uno. If you are just starting now, I suggest that you consider enrolling to Arduino Step by Step, and working through the project in Beginning Arduino.
You do not need to own one of these boards to take advantage of the materials in this course. You can use this course as a reference guide to understanding each board's benefits and disadvantages before you choose one for your next project.
Start learning about Advanced Arduino Boards and Tools now!
- This course will benefit the most students who already have at least a basic working experience with the Arduino Uno
- Students who are looking to upgrade from the Arduino Uno, but don't know which board option is best for their next project
- Students who are curious about Internet of Things platforms, like Temboo
- Students who are curious about the tools used in more complicated Arduino projects, like editors and debuggers
- If you have never worked with the Arduino before, it would be best if you took one of my beginner Arduino courses first
A few words about this course. Please watch before continuing!
The Arduino Zero is an advanced Arduino board with several very useful features.
It has the same footprint as the Arduino Uno, so that many of your existing shields will fit.
It is a 3.3V only board, so you must be careful not to connect any 5V devices to it without a way to step down that voltage.
It is fitted with a 32-bit SAMD21G18 ARM Cortex M0+ microcontroller. This means plenty of computing power for many common applications. It also has a lot more Flash and RAM memory that then Uno.
All of its 20 input / output pins provide PWM capability. On top of that, one pin can be used to create true analog output.
The Zero has a very low power consumption rating, making it ideal for battery powered applications.
A very important feature for more complex applications is the Embedded Debugger chip, which works with Atmel Studio to provide full live debugging features. This chip can also be used to program the SAMD microcontroller.
The Zero has two USB ports. The programming USB port is connected to the Embedded Debugger used for programming and to simulate a serial port. The native USB port is connected directly to the SAMD microcontroller and can be used as a serial port, to simulate a USB device to a host (like a computer) or to connect USB devices to the microcontroller.
In this lecture, I will introduce the Arduino Zero.
The Arduino Zero needs some setting up before you can use it out of the box.
In this lecture, I will show you how to setup your Arduino IDE to work with the Arduino Zero.
If you are using an Arduino M0 Pro from Arduino.org, you will need to fix a bug in the software whereby two of the digital pins are swapped.
One of the neat feature in the Arduino Zero is that the resolution of its PWM analog output can be configured.
While in the Arduino Uno the PWM resolution is fixed to 8-bits, in the zero you can set it to any resolution, up to the maximum 12-bits.
In this lecture I will show you how to set the PWM resolution in the Arduino Zero, and look at an example PWM signal on the oscilloscope.
In the Arduino Uno, we can only simulate the effect of an analog signal on a device like a motor or an LED by using Pulse Width Modulation.
If we need to create a true analog signal with the Arduino Uno, we must use an external digital to analog converter module.
True digital to analog conversion is the ability to convert a number to a voltage. The Arduino Zero has one pin capable of this type of conversion.
In this lecture, I will show you how to use the digital to analog converted (DAC) in the Arduino Zero.
In the previous lecture you had a taste of what you can do with the digital to analog converted in the Arduino Zero.
In this lecture I will demonstrate how to create arbitrary waveforms using tables with recalculated waveform values.
Although you can implement formulas based on which the Arduino Zero can calculate the points on a waveform, for standard waveforms it is often easier to recalculate these values and read them from a data table.
In this lecture I will show you how to recalculate waveform values and use them to generate waveforms on your Zero.
The Arduino Zero is based on a powerful micro controller, but is also a very efficient device.
It is an excellent choice for battery powered applications because it is very nimble when it comes to power consumption.
The Arduino Zero consumes a fraction of the power that the Arduino Uno does for the same tasks. It does this because of the power characteristics in the SAMD micro controller, and because of the more efficient power sub circuit on the board.
In this lecture I will describe these power features and will compare the actual current draw of the Zero against the Uno.
In the Arduino Uno, you can only keep track of the passage of time by counting the milliseconds since power was restored.
There is no simple way to convert the milliseconds value to an actual date and time.
If real-time and date capability is needed in your project, you will need to connect and external clock module.
The Arduino Zero contains a real-time counter feature integrated in the SAMD micro controller. This counter can be used to implement an actual clock, with the ability to tell the time and date, eliminating the need for external components.
In this lecture, I will show you how to setup and use the real time counter, and use it to keep track of real time.
The Arduino Zero comes with two USB ports. The one closer to the power barrel port is the programming USB port, and the other now is the Native USB port.
In the lectures so far, we have worked exclusively with the programming USB port. We used it to program the SAMD micro controller and to get a virtual serial port that it also implements for use with the serial monitor.
In this lecture I will play with the Native USB port. I will give you an example of how you can use it to simulate a keyboard with the Arduino Zero. In a similar way, you can use this port to connect USB peripheral devices to your Zero. Things like full USB keyboards and mice are common.
You can finally use a proper keyboard with your Arduino instead of flexible keypads.
The Arduino 101 is a board packed with features that make it a very interesting option for prototyping, especially of applications in the space of wearables and mobile applications.
This Arduino features an Intel Quark processor on-board, specifically designed for powering mobile, low power applications.
It runs a real-time operating system, which Intel plans to open source in the near future. This will give users the opportunity to tap into the processor’s internal resources.
At the moment, users can use the libraries that Intel has provided to access the build-in 6-axis accelerometer and gyro, Bluetooth Low Energy, and Real-time counter features.
Apart from the Intel micro controller, the Arduino 101 can be programmed with the basic Arduino IDE, and is compatible with the vast majority of the Arduino-Uno style shields. The included level shifters ensure that the board will work with 3.3V and 5V shields and peripherals. A flash module provides additional storage space.
The Arduino 101 is advanced, and it is based on a powerful Intel micro controller.
But that does not mean that it is difficult to use and program. It is a true Arduino board, fully compatible with the familiar Arduino IDE, and as a result very easy to work with.
In this lecture, I will show you how to setup the Arduino IDE so that you can work with the Arduino 101. Once the quick setup process is complete, I will give you a taste of the 101 by demonstrating the Real Time Counter library.
My favourite feature in the Arduino 101 is the integrated BLE radio. This feature makes it possible to create applications that include high-speed, low energy consumption serial communications with any device that support this standard.
With BLE, you can build gadgets that can communicate wirelessly long periods of time, even for years, on a button battery. Most modern computer equipment, like laptops, tablets and smart phones, already support BLE.
The Bluetooth standard specification has provisions for several applications, and through these provisions your gadget can interact with any other device that also implements them. Applications like blood pressure and heart rate monitors, location and navigation, and environmental sensing are some examples.
In this lecture I will discuss some of the basic aspects of Bluetooth, and give a demonstration of one that simply toggles an LED on and off.
Having completed the last lecture, you have a good understanding of what BLE is and how it works with the Arduino 101.
In this lecture, I would like to show you how you can implement an application based on one of the standardised BLE profiles, the Heart Rate profile.
This is the same profile that commercial hear rate monitors use.
Using the same principles, you will be able to create applications by implementing any of the BLE standard profiles, ensuring compatibility with any other device that support it.
The Intel Curie micro-controller that powers the Arduino 101 contains integrated 6-axis gyro and accelerometer sensors. These sensor, combined with an also integrated digital signal processor and the provided library, make the 101 very good at sensing motion.
The Arduino 101 motion sensing features allow you create gadgets that can do things like measure your daily steps, the orientation of the device, and detect shocks.
In this lecture, I will demonstrate some of these applications to help you get an understanding of motion sensing with the Arduino 101.
One aspect of using motion sensors is that the raw data that they generate are not readily useful because of the amount of noise that they contain. For this reason, smoothing and sensor fusion algorithms have been developed. These algorithms that input from multiple sensors, remove the noise, and generate useful output. In a demo in this lecture, I will show you how to use one such algorithm to combine raw readings from the gyro and the accelerometer, and output data that we can use to visualise the position of the Arduino 101 in space.
In this lecture, I will introduce the Arduino Mega 2560 and describe its most important features.
Consider the Arduino Mega 2560 as a super-sized version of the Arduino Uno. It is based on the Atmega 2560, a larger relative of the Uno's Atmega 328p. It runs on the same clock speed, so that all your time-dependent functionality will not be affected. It also runs on the same voltages, so all your Arduino Uno shields and peripherals will just work.
The Mega simply has a lot more of everything. More GPIOs, more serial ports, more analog inputs.
It is the easiest advanced Arduino board to use for anyone who has started with an Arduino Uno.
The Arduino Mega 2560 runs at 5V, and this means that all of the Arduino Uno's peripherals, will work without any issues.
In this lecture I will use one of my very old Arduino Uno color LCD shields with the Arduino Mega 2560.
As you will see, the Mega will have no problems at all with this shield.
The Arduino Mega 2560 has 4 hardware serial ports. In this lecture I will demonstrate how to use 2 of the 4 hardware ports simultaneously.
With these ports, you will be able to attach multiple serial devices to the Mega and communicate with them at full speed, and without the need to use the software serial library.
The Arduino Mega 2560, just like the Uno, depend on a bootloader program to help with uploading sketches from the Arduino IDE.
When you work with other programmes, like the Atmel-ICE, and other IDEs, like Atmel Studio, the bootloader will be erased. This is because these setups don't need it, and since the bootloader shares the same flash memory space as a normal sketch, it get overwritten.
In this lecture, I will show you how to restore the bootloader on the Arduino Mega so that you can use it with the Arduino IDE.
The Arduino Due is an advanced board that looks like the Mega 2560, but has a very different architecture. It is based on an ARM Cortex M3 microcontroller. It is much faster and more energy efficient that the Mega, adds digital to analog converters and a native USB port.
In this lecture, I introduce the Arduino Due.
In this lecture, I will attach an old Arduino Uno Ethernet shield to the Arduino Due. It is a 5V shield, while the Due operates at 3.3V. Despite the risk, I wanted to test if it will work with the Due using the stock-standard libraries. Will it work?
No hardware was destroyed in the making of this lecture!
The Arduino Galileo is a unique board when compared to other Arduino boards because it combines a full Linux computer with an Arduino Uno. The result is a device that combines the advantages of both worlds.
Thanks to the Galileo architecture, your Arduino sketches can take advantage of any programs that runs on the Linux side. Your sketches can use operating system commands, or programs written in powerful languages such as C, Python, and Node.js.
The Arduino Galileo Gen 2 board comes with several peripherals build-in, saving you from the expense of things like an Ethernet shield, and SD card module, or a real time counter. It also comes equiped with a USB host port for connecting a keyboard and mouse, and a second serial port that gives you direct access to Linux. All these features allow you to use all of the Uno-style header pins for digital input and output, instead of occupying them for the peripherals.
In this lecture, I will introduce the Arduino Galileo Gen 2.
The Galileo Gen 2 comes with a reduced, bootable version of Yocto Linux already installed in its flash.
However, to get started, we must first install the supporting drivers and example sketches to the Arduino IDE.
In this lecture, I will show you the process of setting up the Arduino IDE for the Galileo. Then, I will show you the boot process, and upload a simple sketch to test that the board is ready to use.
The reduced version of Yocto Linux that ships with the board is sufficient for most basic tasks that people might want to use the Galileo for.
However, it does not provide support for the Wifi module, Secure Shell, or Python, among many other features. It does not even provide persistence for your sketches after a power loss or reboot.
To take full advantage of what the Galileo can do, you must setup and use the full Yocto Linux operating system.
In this lecture, I will show you how to install the full Yocto Linux OS, and discuss some of its benefits.
The Galileo Gen 2 comes equipped with a micro SD card module.
This slot is used to store the full version of the Yocto Linux operating system. It is also usable by Arduino sketches.
You can use the file system available on the SD card to store sensor data, read and write configuration files, or interact with the Linux operating system.
In this lecture, I will give you a demonstration of some of the things you can do with the integrated SD card module.
The Arduino Galileo Gen 2 comes equipped with a mini PCI card slot in which you can insert a low cost wifi module.
The full version of the Yocto Linux operating system contains the necessary drivers to support the wifi module. Just like with the Ethernet port, the Wifi module can be shared by both the Linux operating system and the Arduino sketches.
In this lecture, I will show you how to setup the wifi module, and demonstrate its use from within an Arduino sketch.
Although accessing the Arduino input and output pins is trivial through our Arduino sketches, it is useful to know that these pins are also accessible by Linux.
Unfortunately, the process of accessing the Arduino header pins through Linux is by no means trivial.
In this lecture I will give you a demonstration of how it can be done.
Keep in mind that the process can be made easier through the use of specially designed Python libraries. However, at the time of creating this lecture I had not been able to find one that I felt was good enough to include.
The Galileo Gen 2 is an Arduino, so it is compatible with most commonly used Arduino peripherals.
The Galileo is designed to work with both 3.3V and 5V shields and peripherals.
In this lecture, I am testing to see if a component that I use a lot with my Arduino Uno, the 16x2 LCD character screen connected to a I2C backpack interface, can be used with the Galileo.
Another peripheral I often use in my Arduino Uno projects is a color OLED screen, connected via the SPI interface
In this lecture, I will try to make it work with the Galileo.
I will use the same wiring, and the same libraries that I use with the Arduino Uno.
Will it work? Let’s see!
Debugging is the process of finding and resolving of defects that prevent the correct operation of computer software or hardware systems.
Debugging tends to be harder as systems become larger or more complicated.
Specialized tools can be used to make debugging more efficient.
Atmel Studio is a rich, Integrated Development Environment for developing applications for Atmel’s micro-controllers. It is based on Microsoft’s Visual Studio and works only on Windows computers. It can also be used with the Arduino and can replace the basic Arduino IDE. Atmel Studio offers sophisticated device and library support, an advanced editor, a solution explorer, advanced hardware debugging capabilities, and can be extended via plug-ins.
Atmel Studio is a Windows-only Integrated Development Environment. It is based on Microsoft’s Visual Studio, and it supports Atmel’s various micro-controllers.
In this lecture, I will show you how to install Atmel Studio and how to create a new Arduino project. An Atmel Studio Arduino project contains your Arduino sketch file or files, the Arduino core library files and the files of any third party libraries that your sketch needs, as well as various configurations.
A hardware debugging tool is used to probe the state of a sketch running inside a micro controller, and provides assistance during a debugging session.
The Terminal window is similar to the familiar Serial Monitor in the Arduino IDE. It makes it possible to view text messages printed by the running sketch.
You can use breakpoints to cause execution to stop at a specific line of code, when that line is reached.
You can use tracepoints to monitor the state of your sketch at a specific line, without stopping execution.
You can modify the default behaviour of breakpoints and tracepoints by defining conditions and actions.
For example, you can create log messages that contain variable values, or calculate expressions.
Atmel Studio will overwrite the bootloader when you use it to upload a sketch to your Arduino.
Without a bootloader, the Arduino IDE will not be able to upload a sketch to your Arduino.
In this lecture, I will show you how to restore the Arduino bootloader on the Arduino Zero using the Arduino IDE.
Temboo is a Cloud service that makes it possible to create applications that combine Internet-of-things hardware with many useful online services.
Tempo provides an infrastructure that makes it relatively easy to get data from an Arduino (or some other hardware platform), and integrated it will online services provided by companies like Google, Amazon and Dropbox. Temboo will not only provide the this infrastructure that acts as the glue between the hardware and the cloud software, but it will also generate the code that should run on your Arduino to make the integration possible.
Temboo is not only there to connect hardware to cloud services: it can connect software that your write and you can execute on your computer to cloud services. Think of Temboo as an integrator: it connects software and hardware things to the Cloud.
In this lecture, I will introduce Temboo and discuss its basic concepts, especially that of the Choreo, the basic unit of functionality based on which you can create your own workflows.
Now that you have an understanding of what Temboo is, we can begin the process of creating a new Choreo.The function of this chores will be to acquire sensor data from an Arduino, and store the data in a Google Spreadsheet.
In this lecture, I will walk you through the process of setting up the Choreo in Temboo.
Because our choreo will be accessing a Google Cloud service, we will also need to setup the appropriate credentials containing the permission necessary to do so.
Once you complete and understand this lecture, you will know how to integrate any of the available Google services with a Temboo Choreo.
In the previous lecture, you learned how to create a new Temboo Choreo and setup the appropriate credentials and permissions so that it can access a Google Spreadsheet.
In this lecture, I will show you how to complete the setup.
I will show you how to generate the code for your Arduino that takes into account your type of Arduino board and your available networking hardware.
I will also show you how to use Temboo Profiles to reduce any security risks and improve the flexibility of your Choreos.
We will then take the code that Temboo generated based on our choices, upload it and run it on an Arduino.
In the previous lecture you learned how to setup a Choreo so that it stores sensor data to a Google Spreadsheet.
In this lecture I will show you how to use Google’s Gmail service to enable your Arduino to send out emails containing the same sensor data in an arbitrary message.
As you will see, the process of setting up the Gmail chores is very similar to that of the Spreadsheet choreo. The biggest difference is that in Gmail, authorisation works in a different way to that of Google Spreadsheets.
If you don’t use Gmail, you can simply opt to use a generic email Choreo.
The two chores you have learned learned about so far are useful on their own.
But things get a lot more interesting once you learn how to combine choreos into workflows.In this lecture, I will show you how to do this.
We will create a demo sketch running on the Arduino that uses a button to trigger the a series of functions:
First, it will get data from the environment sensor.
Second, it will store the data in a Google Spreadsheet.
And third, it will send you an email with the same data.
Creating Choreo workflows is surprisingly easy, let me show you!
In our exploration of Temboo up to now, data has traveled from the Arduino, to Temboo and then to the targeted cloud services. What about the opposite: can we get Temboo to send data to the Arduino?
That is a rhetorical question, obviously!
Of course we can! Temboo can send response values to your Arduino. The Arduino then can invoke a physical action based on these values, like turning an LED or a motor on and off.
In this lecture, we will build on the combined choreo workflow from the previous lecture, and we will add a hardware output event.
We will adjust the sketch so that when the data is successfully recorded in the Google Spreadsheet, an LED on the Arduino will be turned on.
This is the last lecture in this section. Let’s begin!
Processing is a framework that has been designed with a strong emphasis in creating rich visual outcomes. Processing not only has influenced the Arduino IDE and programming language, but it also works very well together.
In this lecture, I will introduce Processing, the language. Processing is an open source programming language initiated by Ben Fry and Casey Reas, and developed by a team of volunteers.
Processing is an excellent choice for people that wish to learn how to program and has an extensive graphics library which makes it ideal for visual artists, or anyone wanting to create visually rich applications.
Why I am including Processing in this course? Because Processing works very well with the Arduino. With Processing, we can create stand-alone desktop applications that interact with the Arduino via a serial communication channel, such as USB/TTL and Bluetooth. Processing opens up a whole array of possibilities that are worth considering, with a very low barrier to entry.
In this lecture, I will show you how to setup Processing on your computer, and demonstrate some of the features of its development environment.
As you will see, setup is very simple.
As an Arduino maker, you will find the Processing IDE very familiar to the Arduino IDE. It is easy to install libraries, play with examples, run and debug sketches.
The programming language itself is also familiar to anyone that has worked with the Arduino.
In this lecture I will walk you through these aspects of Processing, as well as some of the online resources available.
Firmata is a protocol designed for micro controllers to communicate with a host computer. With Firmata, the programmer can create applications on a computer that interact with a remote micro controller and read or change that state of the micro controller’s pins.
On the Arduino, Firmata is implemented as a sketch (or firmware). Once the Firmata sketch is uploaded to the Arduino, it is able to interact with a host computer running a program that also implements the Firmata protocol.
In this lecture I will demonstrate how you can use Firmata to make it possible for an Arduino to interact with a Processing sketch.
One of the core strengths of the Processing language is the ease by which graphics can be programmed.
In this lecture I will show you how to visualise data from the accelerometer in the Arduino 101 board.
I will discuss the 2-D graphics primitive, colors, the structure of a Processing sketch, and 2-way communications between the Arduino and the host computer.
Elsewhere in this course, I showed you how to debug a sketch running on the Arduino Zero using Atmel Studio and the onboard EDBG chip. This is a powerful combination, making it possible to develop reliable applications without any additional hardware.
Arduino Zero’s onboard debug tool represents a significant advantage, because at a price very close to that of the Uno, it offers a powerful SAMD micro controller with build-in hardware debugging.
In this lecture, I introduce OpenOCD and GDB. With these tools, you can debug your Arduino Zero application relying completely on open source software. Both ship with the Arduino IDE. If you have the Arduino IDE, then you already have OpenOCD and GDB.
OpenOCD is an open source and free on-chip debugger. It is used to program and debug embedded devices. In the case of the Arduino Zero, OpenOCD works with the on-board EDBG chip, which plays the role of the debug adapter. The debug adapter is the interface that allows OpenOCD to interact with the firmware that is running in the target micro-controller.
GDB is the debugging tool developed and maintained by the GNU project. This is the tool that we interact with during a debugging session. GDB allows us to step into or over the code, to inspect and set variables, to set breakpoints, as well as many other related functions.
In this lecture, I will introduce OpenOCD and GDB. In the next two lectures, I will show you how to use these tools.
OpenOCD and GDB are command line tools. As a result, many people find it hard to use them.
In this lecture, I will show you how to prepare a debugging session of a sketch that is running on an Arduino Zero.
Then, I will show you where to find the tool binaries in your Arduino installation, and how to start them.
This process may seem tedious at first. I promise that if you practice it a couple of times, you will be able to start a debugging session within seconds.
Now that we have started OpenOCD and GDB, it is time to do some debugging!
In this lecture, I will demonstrate some of the most useful GDB commands and workflow.
I will show you how to inspect and set variables, create breakpoints, step over and into the code, inspect the stack. I will also show you how to use the enhanced GUI version of the GDB interface.