What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Arduino Android Blueprints

Chapter 1. Setting Up Your Workspace

The first chapter of this book will teach you the basics of the Arduino and Android development so that you can be sure you have the basics required for the more advanced tutorials you will find in the rest of this book.

On the Arduino side, we will build a very simple project with a relay module (which is basically a switch that can be controlled with Arduino) and a temperature and humidity sensor. We will also see the basics of the Arduino IDE and the basic commands of the aREST library, which is a framework to easily control Arduino boards. We will use this library in several chapters of this book to make it really easy to control the Arduino board from an Android device. In this first chapter, we will simply try out the commands of the aREST library by having the Arduino board connected to your computer via a USB.

From the Android development point of view, we will work together to set up a development environment and ensure that your computer and the Android device are ready for development purposes. We will start off with a simple Android app that displays the legendary text, Hello World.

Android Studio is an IntelliJ-based Integrated Development Environment (IDE) fully supported by the Android development team, which will provide you with the necessary tools and resources to make sure that you develop a functional and aesthetic Android app.

Android Studio is in beta but the software is updated on a frequent and regular basis by a dedicated team at Google, which makes it the natural choice to develop our Android projects.

Hardware and software requirements

The first thing you will need is an Arduino Uno board. We will use this board throughout this book to connect sensors, actuators, and wireless modules and make them interact with Android. Then, we will need a relay module. A relay is basically an electrical switch that we can command from Arduino, which can allow us to control devices such as lamps. This project uses a 5V relay module from Polulu, which properly integrates a relay on a board, along with all the required components to control the relay from Arduino. The following is the image of the relay module that was used in this chapter:

You will also need a DHT11 (or DHT22) sensor, along with a 4.7K resistor, for temperature and humidity measurements. A resistor is basically a device to limit the current flowing into an electrical device. Here, it is necessary to ensure the correct functioning of the DHT sensor.

Finally, you will need a small breadboard and jumper wires to make the different hardware connections.

The following is the list of all hardware parts you will need for this project, along with links to find these parts on the Web:

The Arduino Uno board (http://www.adafruit.com/product/50)
The 5V relay module (http://www.pololu.com/product/2480)
The DHT11 sensor and 4.7K Ohm resistor (https://www.adafruit.com/product/386)
The breadboard (https://www.adafruit.com/product/64)
Jumper wires (https://www.adafruit.com/product/758)

On the software side, you will need the Arduino IDE that we will also use in the rest of this book. You can get it at http://arduino.cc/en/Main/Software.

The installation process of the IDE is very simple; you simply have to open the file and follow the onscreen instructions.

You will need the library for the DHT11 sensor, which can be found at https://github.com/adafruit/DHT-sensor-library.

You will also need the aREST library found at https://github.com/marcoschwartz/aREST.

To install a given library, simply extract the folder in your Arduino/libraries folder (or create this folder if it doesn't exist yet). Your Arduino folder is where all the sketches are stored, and you can define this folder in the preferences of the Arduino IDE.

Preparing for Android development requires that we get ready to design and develop the app, and the following checklist will guide you with having the basics ready for any project:

Java Developer Kit Version 6 (or higher)
Android Studio
Android Software Development Kit
Android Device with Bluetooth SMART technology

We will also work together to make sure that you have everything properly set up.

Installing Java Developer Kit

Android Studio will not work without Java Developer Kit (JDK); therefore, it's necessary to know what Java version you have installed (in this particular case, the Java Runtime Environment will not be enough).

Checking the JDK version

It is mandatory that you check the version of your JDK for compatibility purposes.

Mac

Open Terminal and type the following command:

java –version

This is what will be shown on the screen:

Windows

Open Command Prompt and type the following command:

java -version

This is what will be shown on the screen:

Installing Java

If you do not have Java installed, or if your version is below 6.0, install the Java JDK by clicking on the following customized and shortened link and choosing the version that applies for you:

http://j.mp/javadevkit-download

The following window will open:

The main recommendation for these projects is that you install a version of JDK 6.0 or higher.

Select the JDK for your operating system. On an Intel-based Mac, you can follow this useful table to see whether your Mac is 32-bit or 64-bit:

Processor Name	32- or 64-bit processor
Intel Core Solo	32 bit
Intel Core Duo	32 bit
Intel Core 2 Duo	64 bit
Intel Quad-Core Xeon	64 bit
Dual-Core Intel Xeon	64 bit
Quad-Core Intel Xeon	64 bit
Core i3	64 bit
Core i5	64 bit
Core i7	64 bit

You can check for Processor Name by clicking on the Apple logo in the top-left corner of your screen followed by About my Mac.

In the case of Windows, to see whether your computer is running a 32-bit or 64-bit version of Windows, you need to do the following:

Click on the Start button.
Right-click on My Computer, and then click on Properties. If x64 edition is listed under system, your processor is capable of running 64-bit-enabled applications.

Setting up the Android Software Development Kit

The process of setting up the Android Software Development Kit (SDK) has improved vastly with the introduction of Android Studio, as the latest SDKs come preinstalled with the Android Studio install package. In order to develop the projects detailed in the following chapters, it would be very helpful to understand how you can install (or even uninstall) SDKs within Android Studio.

There are a number of ways to access the SDK Manager. The most straightforward way is through the following Android Studio main toolbar:

Another option would be via the Launch menu where you will be faced with the following options:

In order to access the SDK Manager, you will need to click on Configure, where the following screen will appear, and then click on SDK Manager:

The previous screenshot shows us what the SDK Manager looks like. If you need to install any packages, you need to check the mark of that particular package, click on Install packages, and then finally accept the licenses, as shown in the following screenshot:

Setting up your physical Android device for development

The following are the three main steps that need to be executed in order to enable your Android device for development:

Enable Developer options on your specific Android device.
Enable USB debugging.
Entrust the computer with an installed IDE via secure USB debugging (devices with Android 4.4.2).

Enabling Developer options

Depending on your device, this option might vary slightly, but from Android 4.2 and higher, the Developer options screen is hidden by default.

To make it available, go to Settings | About phone and tap on Build number seven times. You will find Developer options enabled by returning to the previous screen.

Enabling USB debugging

USB debugging enables the IDE to communicate with the device via the USB port. This can be activated after enabling Developer options and is done by checking the USB debugging option by navigating to Settings | Developer options | Debugging | USB debugging.

Entrusting the computer with the installed IDE using secure USB debugging (devices with Android 4.4.2)

You have to accept the RSA key on your phone or tablet before anything can flow between the device via Android Debug Bridge (ADB). This is done by connecting the device to the computer via a USB, which triggers a notification entitled Enable USB Debugging.

Check Always allow from this Computer followed by clicking on OK.

Learning to use the aREST library

Now that our hardware is assembled, we are going to see the basics of the Arduino environment, and how to use the aREST library that we are going to use in several chapters of this book to control Arduino from an Android phone.

The aREST library will allow us to simply control the Arduino board externally using the same commands, whether it is using an USB cable, Bluetooth, or Wi-Fi. Without this library, we will have to rewrite the same code several times for all the chapters of the book. To find a complete documentation on the aREST library, you can visit https://github.com/marcoschwartz/aREST.

The main window of the Arduino IDE is where you enter the code to program the Arduino board.

Arduino code files are usually called sketches. The following screenshot is of the Arduino IDE with the code of this chapter already loaded:

You will basically use two buttons that you can find on the left-hand side of the toolbar. The first one, with the check sign, can be use to compile the code. The second one will be used to upload the code to the Arduino board. Note that if the code has not been compiled yet, the upload button will also compile the code before uploading.

The second important window of the Arduino IDE is called the serial monitor. This is where you can monitor what your Arduino project is doing, using the Serial.print() statements in the code to generate debug output. You can access it by clicking on the top-right icon of the Arduino IDE main window.

The following screenshot shows what the serial monitor looks like:

We are now going to build our first Arduino sketch in this book. What we want to achieve is simply to control the relay and read data from the DHT11 sensor. To do so, you are going to use the aREST library by sending commands from your computer. In the next chapter of this book, we are going to use the same commands but via a Bluetooth or Wi-Fi connection. The goal of this section is really to make you familiar with the commands of the aREST library.

The following code is the complete Arduino sketch for this part:

// Libraries
#include <aREST.h>
#include "DHT.h"

// DHT sensor
#define DHTPIN 7
#define DHTTYPE DHT11

// Create aREST instance
aREST rest = aREST();

// DHT instance
DHT dht(DHTPIN, DHTTYPE);

// Variables to be exposed to the API
int temperature;
int humidity;

void setup(void) {
  // Start Serial (with 115200 as the baud rate)
  Serial.begin(115200);
  
  // Expose variables to REST API
  rest.variable("temperature",&temperature);
  rest.variable("humidity",&humidity);
  
  // Give name and ID to device
  rest.set_id("001");
  rest.set_name("arduino_project");
  
  // Start temperature sensor
  dht.begin();
  
}

void loop() {  
  
  // Measure from DHT
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  temperature = (int)t;
  humidity = (int)h;
  
  // Handle REST calls
  rest.handle(Serial);
  
}

Let's explore the details of this Arduino sketch using the following steps:

The Arduino sketch starts by importing the required libraries for the project:
```
#include <aREST.h>
#include "DHT.h"
```
After that, we need to define on which pin the DHT11 sensor is connected to, and which is the type of the sensor:
```
#define DHTPIN 7
#define DHTTYPE DHT11
```
We also need to create an instance of the aREST library:
```
aREST rest = aREST();
```
We also need to create an instance of the DHT11 sensor so that we can measure data from it:
```
DHT dht(DHTPIN, DHTTYPE);
```
Finally, we need to create two variables that will contain our measurements:
```
int temperature;
int humidity;
```
In the setup() function of the sketch, we need to start the serial port:
```
Serial.begin(115200);
```
Next, we need to expose our two measurement variables so that we can access them via the serial port using the aREST library. Note that we have to pass the reference to these variables, not their values, as shown in the following code:
```
rest.variable("temperature",&temperature);
rest.variable("humidity",&humidity);
```
We also set an ID and name to our project. This will not play any role here, but is simply to identify our board in case we have many of them:
```
rest.set_id("001");
rest.set_name("arduino_project");
```
Finally, we start the DHT11 sensor:
```
dht.begin();
```
Now, in the loop() function of the sketch, we make the measurements from the DHT11 sensor, and convert these measurements to integers (which is called "casting" in C):
```
float h = dht.readHumidity();
float t = dht.readTemperature();

temperature = (int)t;
humidity = (int)h;
```
Note that here we are converting these numbers into integers because it is the only variable type supported by the aREST library. However, as the resolution of the DHT11 sensor is limited, we are not losing any information here. Finally, we handle any requests coming from the outside using the following code:
```
rest.handle(Serial);
```
Note
Note that all the code for this chapter can be found in the GitHub repository of the book at the following link:
https://github.com/marcoschwartz/arduino-android-blueprints

It's now time to upload the sketch to your Arduino board. If you have any error when compiling, make sure that you installed all the required Arduino libraries for this chapter.

When this is done, simply open the serial monitor (making sure the serial speed is set to 115200). Note that you could do the same with your own serial terminal software, for example, CoolTerm found at http://freeware.the-meiers.org/.

Now, we are going to test that the aREST library is working correctly. Let's proceed with the following steps:

First, we are going to query the board for its ID and name. To do so, type the following:
```
/id
```

You should be greeted by the following answer:

{"id": "001", "name": "arduino_project", "connected": true}

We are now going to see how to control the relay, as this is something we are going to do several times in this book. First, we need to define that the relay pin, which is pin number 8 of the Arduino board, is an output. To do so, we can simply type:
```
/mode/8/o
```

You should receive the following answer on the serial monitor:

{"message": "Pin D8 set to output", "id": "001", "name": "arduino_project", "connected": true}

Now, to activate the relay, we need to set the pin 8 to a HIGH state. This is done the following command:
```
/digital/8/1
```
You should instantly receive a confirmation message, and hear the relay click. To switch the relay off again, simply type the following code:
```
/digital/8/0
```
Now, we are going to read data from the board using the aREST library. For example, to read the temperature variable, you can simply type the following code:
```
/temperature
```
You will receive the following confirmation message with the value of the temperature:
```
{"temperature": 28, "id": "001", "name": "arduino_project", "connected": true}
```
You can do the same for humidity:
```
/humidity
```

You will receive a similar message back:

{"humidity": 35, "id": "001", "name": "arduino_project", "connected": true}

If this is working, congratulations! You now know the basics of the aREST library that we will use throughout the book. Note that for now we are using these commands via serial communications, but later in the book, we will first use the same commands via Bluetooth, and then via Wi-Fi to command the Arduino board from an Android device.

Now that we have seen how the aREST library is working, we are going to create our first Android project. Note that in this introductory chapter, we won't connect both together; this will be done in the next chapter of the book.

Creating your first Android project

In order to get started in the world of Android application projects, it would be very useful to set up a very basic project that goes through the two main processes in Android application development: coding the application and then testing it on an Android physical device.

Tip

Downloading the example code

You can download the example code files for all Packt books you have purchased from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

Setting up your first Hello Arduino project

Click on New Project when Android Studio launches as shown in the following screenshot:

An important step within Android application development is configuring your project. This project will be using Android 4.3 as the minimum target SDK, since we intend to use the Bluetooth Low Energy API, which was introduced in this particular version of Android. In this case, we will name the project Hello Arduino and write down your company domain, as the convention for application package names is the reverse of your chosen domain.

Refer to the following screenshot:

For the purposes of this particular project, we will go ahead and choose the most basic project, Blank Activity, as shown in the following screenshot. The other choices provide added functionality that we do not need at this stage.

In the following screenshot, we choose Blank Activity, and we need to give a name to our main Java file. Let's keep it as MyActivity:

Once you follow through all the previous steps, you will be welcomed to this workspace, which gives a good overview of the project tree, main code editor, and the device that shows a preview of the User Interface (UI), as shown in the following screenshot:

In this particular project, there will be no need to modify the existing code and therefore we will proceed with building our app and launching it on our physical Android device.

Installing your app on your physical device

Previously, we have connected and enabled our physical Android device via a USB. Within Android Studio, we need to set up the configuration to run our Android application.

This is done by choosing Editing Configurations from the main toolbar as shown in the following screenshot:

Installing your app on your physical device

In the Editing Configurations window, we will click on the + sign and choose Android Application where we set up the configuration with the following settings and confirm them by pressing OK:

After setting up everything, we are ready to run the app. Choose the App configuration, which we previously set up, and press the Play button (green triangle) as shown in the following screenshot:

There is the possibility of creating an Android Virtual Device (AVD) to install the application. However, at this point in time, there are no virtual emulators that support Bluetooth, which we will need for a number of projects in this book. So, we will focus on setting up your Android physical device running Android 4.3 or higher.

In the next step, choose your physical device and press OK, as shown in the following screenshot:

You should expect the following to show up on your Android device if you have set up everything in the correct manner:

What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Frequently bought together

zł197.99

zł197.99

zł104.99

Total zł 500.97

Zachary L. Stauber Sep 29, 2017

I am giving this 5 stars because I don't think there are any other books like it, but it does come with some warnings. I bought it specifically for the Android controlled Bluetooth robot plans near the end of the book. The author gives links directly to parts on the DFRobot and Adafruit websites supplying the parts he uses, which is great, and he explains everything very well.The links still work. However, particularly in the case of DFRobot, some of their parts had actually changed since the book's printing, so you'll need to order extra parts to fill in the now-missing pieces (in my case, some longer metal standoffs, a charger for the battery, and some extra jumper wires).In addition, you will need to learn to solder to affix header pins to the Bluetooth module, so you'll need a soldering kit, which immediately bumps up anything Arduino to at least intermediate skill level, as the Arduino starter kit doesn't touch on soldering.The worst part, though, was that the Android libraries have all changed since late 2014, and the Android code in the book, which I'm sure worked when the book was written (it compiles fine), now throws exceptions all over the place and does not connect a phone to the robot. Luckily I downloaded some source code for the Nordic Semiconductor's nRF UART app which was recommended by Adafruit to test the Bluetooth module used on the robot, which did work with the newer Android SDK's, and I was able to adapt that to get the robot connecting and working.However, all of this took at least 3 extra orders of parts (including the soldering kit) and reviewing numerous tutorials online on soldering and Android programming, which I was not prepared for. The extra orders did not cost a lot of extra money, but DFRobot is in Hong Kong, so sometimes it took weeks.All of that being said, none of this is the book's fault. These were changes made by DFRobot to products without changing their part numbers, and by Google to the Android SDK's which invalidated working source code. This book got me pretty far, and I was able to get the rest of the way using free online tutorials. I don't think there are any other books out there, yet, that would even do that much.

Amazon Verified review

SA Mar 11, 2015

Very well documented projects. As the title says, you should have a working knowledge of Android development for these projects but no need to be an expert Android developer.You may want to buy the book first and browse some of the hardware lists near the beginning of most chapters. The hardware lists are complete and also include the URL of the various parts suppliers.Found the projects easy to follow and so far, all work well for me through the first 3.

Chaminda Divitotawela Feb 25, 2015

I love this book as it start from very beginning. It is learn by practising and I love that model because it is so effective. Any one who love hobby electronics and integrate it with Andriod and Ardunio, then this is the book. You don't need great deal of knowledge in either very much. I feel anyone with some background in programming would be able to use this for best.

David Jan 29, 2015

Great book, the projects where easy to follow and explained pretty well. I would recommend you look at each project and figure out what you need to build it. Then order the components right away. I found my self waiting... and it was hard not to keep reading. The authors leaves github links so you can download the code if you get lost. Over a great book for learning more about he Arduino platform.

Arduino Android Blueprints: Get the best out of Arduino by interfacing it with Android to create engaging interactive projects

What do you get with Print?

Arduino Android Blueprints

Chapter 1. Setting Up Your Workspace

Hardware and software requirements

Installing Java Developer Kit

Checking the JDK version

Mac

Windows

Installing Java

Installing Android Studio

Mac

Windows

Setting up the Android Software Development Kit

Setting up your physical Android device for development

Enabling Developer options

Enabling USB debugging

Entrusting the computer with the installed IDE using secure USB debugging (devices with Android 4.4.2)

Hardware configuration

Learning to use the aREST library

Note

Creating your first Android project

Tip

Setting up your first Hello Arduino project

Installing your app on your physical device

Summary

Page 1 of 9

Description

Product Details

What do you get with Print?

Product Details

Frequently bought together

Table of Contents

Customer reviews

People who bought this also bought

About the authors

FAQs

Arduino Android Blueprints: Get the best out of Arduino by interfacing it with Android to create engaging interactive projects

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Mac

Windows

Enabling Developer options

Enabling USB debugging

Entrusting the computer with the installed IDE using secure USB debugging (devices with Android 4.4.2)

Note

Description

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Customer reviews

People who bought this also bought

About the authors

FAQs