Android Things - Hardware Basics for the Software Engineer

Android Things is the new kid on the block. It is Google’s embedded platform designed specifically for use with low-powered, IoT (Internet of Things) devices. The Android Things dev preview is available for a few different IoT boards, such as the Raspberry Pi 3, the Intel® Edison and the NXP Pico i.MX6UL.

As someone who has never worked with circuits, I had a bit of a steeper learning curve than others when tinkering with Android Things. I have studied all the theory around circuits and how they work but we never actually had hands on experience creating circuits. Besides that, school was a long time ago, so I needed to brush up on my theory too.

I think it is important to understand the basics of circuits and hardware components before diving in head first into Android Things development. This post will explain the basics of circuits, hardware components and how we can use this knowledge to build a simple blinking LED with Android Things.

Hardware Components

There are different parts you would typically need to build something with Android Things (or any other IoT platform for that matter) depending on what you want to build.

Breadboard – This is your construction base for prototyping electronics. It allows you to connect different components and wires to create a circuit. When you are finished prototyping, you would typically solder your components together and not use a breadboard anymore. The columns on the edges of the breadboard are connected vertically by conductive metal strips, and the inner rows are connected horizontally. Read more about breadboards here.

Jumper Wires – Used to connect the components of a breadboard together and to connect an IoT board (Raspberry Pi, Arduino etc) to the breadboard.

Resistors – Components that are used to resist the flow of electrical energy. It converts some of the electrical energy into heat. Resistors can have different resistance. It is important to calculate and use the correct resistor when building circuits. The stripe markings on a resistor reflect the resistance measure. More info on how to calculate resistor values can be found here.

LEDs – Components that convert electrical energy into light energy. LEDs (or Light Emitting Diodes) are polarized components, this means they only allow electricity to flow in one direction. The short leg of the LED is called a cathode(-) and will connect to ground. The long leg of the LED is an anode(+) and will connect to power.

Push Switch – Component which allows electricity to flow between its two contacts. When the switch is pushed down, the circuit is closed. When the switch is up, the circuit is open.

And many more components!

Power Calculations

When building a circuit, you need to do some calculations before plugging components into one another. For example, an LED can only handle certain a certain amperage (about 0.023A). If you provide more amps than it can handle, you can risk damaging your LED. This is where resistors come in. In order to build a basic circuit where we have a blinking LED, we need to do some calculations as to what resistor we should use.

This is where Ohm’s Law comes in handy. Ohm’s Law states that the current through a conductor between two points is directly proportional to the voltage across the two points. This law will help us calculate the resistors we should use when creating our circuits.

Ohms Law: V = I * R

This diagram translates into 3 different equations: V = I * R or I = V/R or R = V/I, where V is Voltage (volts), I is Current (amps) and R is Resistance (ohms).

GPIO Pins

With the Raspberry Pi 3 (and the other Android Things supported boards), there are a couple of GPIO (general purpose input output) pins that give us a physical interface between the Pi and our breadboard. The pins allow us to interact with different components and receive and send information to them. Each board is configured differently and the pins themselves provide different functionality. To understand how these GPIO pins work for each board, you should look at the manufacturer’s pinout diagram.

For example the pinout diagram for the Raspberry Pi 3 can be seen below:

Raspberry Pi 3 Pinout – Source – https://developer.android.com/things/hardware/raspberrypi-io.html

There are 40 pins on the Raspberry Pi 3 and you can see they have different functions. Some pins provide power, some are ground and others will be used for receiving or sending values to our circuit’s components.

Basic circuit for a blinking LED with Android Things

To create the blinking LED example, we need to create a circuit. In this example, we will be using the Raspberry Pi 3. Using the Fritzing tool, I have created this example circuit that we want to build using our components.

Android Things - Raspberry Pi 3 and Blinking LED — Android Things – Raspberry Pi 3 and Blinking LED

In the diagram above, the pins correspond to the Raspberry Pi pinout diagram shown earlier. In this example, we have used a 220Ω resistor, an LED and some jumper wires to connect them all together. We are supplying the circuit with 5V of power from the Raspberry Pi 3.

When applying Ohm’s Law, we can see that the amps that will flow through the LED is I = 5V/220Ω which means I = 0.023A or 23 milliamps (23mA). This value is just about the max you can safely use with the LEDs, which is why we chose a 220Ω resistor. Some LEDs can handle different currents, it is worth checking out the specs for the LED you are using.

When setting up the above circuit with the Raspberry Pi 3, it is important to ensure the pins are used in the correct place as we mentioned before, since the pins have different uses. Make sure to connect the BCM6 pin (as indicated in the pinout diagram) to the 220Ω resistor.

It is also important to place the LED correctly into the breadboard, with the anode(+) (longer leg) connecting to power and the cathode(-) (shorter leg) to ground, otherwise you might not see a blinking LED.

The LED will not blink until we deploy an app to the Raspberry Pi. However, we can test that the circuit closes by connecting it to the 5V power directly instead of the BCM6 pin and the light should stay on at this point (but be sure to reconnect it to the BCM6 pin so that the example code will run).

The connected components on the breadboard can also be viewed as a simple circuit diagram which may be easier to understand:

Circuit Diagram - Android Things — Circuit Diagram – Android Things

Creating a blinking LED Android Things app

We have covered how to set up a basic circuit and discussed some hardware components. Now we need to start making the LED blink. In order to do this, we will create an Android app that sends signals via the Raspberry Pi to make the LED blink.

We need to first install Android Things on our Raspberry Pi 3. The official guide on the Android Things site is great at explaining how to do this, so I won’t go into that detail here. Once we have deployed the Android Things OS and connected to the device via ADB, we can create the project.

Open Android Studio, click “Create New Project” and then create a project using a blank activity named BlinkingActivity
Once our project is created, add the Android Things dependency. In your app level build.gradle:
```
dependencies {
    provided 'com.google.android.things:androidthings:0.1-devpreview'
}
```
Add the <uses-library> tag into AndroidManifest.xml to indicate that this app requires the Android Things libraries on the device.
```
<application ...>
    <uses-library android:name="com.google.android.things"/>
 
</application>
```

Specify the BlinkingActivity to be the launcher activity in the AndroidManifest.xml. This indicates that the activity will run by default when the device is turned on.

<activity android:name=".BlinkingActivity">.
        <!-- Required for Android Studio default launching -->
        <intent-filter>
            <action android:name="android.intent.action.MAIN"/>
            <category android:name="android.intent.category.LAUNCHER"/>
        </intent-filter>

        <!-- Launch this activity on boot -->
        <intent-filter>
            <action android:name="android.intent.action.MAIN"/>
            <category android:name="android.intent.category.IOT_LAUNCHER"/>
            <category android:name="android.intent.category.DEFAULT"/>
        </intent-filter>
    </activity>

We will use the PeripheralManagerService to control the behaviour of our LED. Open the connection to the pin in onCreate and close the connection in onDestroy . Set the initial direction of the pin to be DIRECTION_OUT_INITIALLY_LOW which means we are using the pin as an output pin and initially it should be a low voltage supplied to it.

public class BlinkingActivity extends Activity {

    private static final String TAG = "BlinkActivity";
    private Gpio ledGpio;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_blinking);

        PeripheralManagerService service = new PeripheralManagerService();
        try {
            String gpioPinName = BoardDefaults.getGPIOForLED();
            ledGpio = service.openGpio(gpioPinName);

            ledGpio.setDirection(Gpio.DIRECTION_OUT_INITIALLY_LOW);

        } catch (IOException e) {
             throw new RuntimeException("Problem connecting to IO Port", e);
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        try {
           ledGpio.close();
        } catch (IOException e) {
           Log.e(TAG, "Error on PeripheralIO API", e);
        }
    }
}

To make the LED blink, we will create a Handler which we post messages to every 500ms to change the state of the LED. We post to the handler in onCreate . Inside the handler, we invert the current value of the ledGpio object by calling ledGpio.setValue() . This will blink the LED.

public class BlinkingActivity extends Activity {

  ...
    private static final int INTERVAL_BETWEEN_BLINKS_MS = 500;
    private Handler blinkingLedHandler = new Handler();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        blinkingLedHandler.post(blinkingRunnable);
        ...
    }

    @Override
    protected void onDestroy() {
        ...
        blinkingLedHandler.removeCallbacks(blinkingRunnable);
        ...
    }

    private Runnable blinkingRunnable = new Runnable() {
        @Override
        public void run() {
            try {
                ledGpio.setValue(!ledGpio.getValue());
                blinkingLedHandler.postDelayed(blinkingRunnable, INTERVAL_BETWEEN_BLINKS_MS);
            } catch (IOException e) {
                Log.e(TAG, "Error on PeripheralIO API", e);
            }
        }
    };

}

Make sure your device is connected and deploy the app to the device. You should see a blinking LED!The code for this tutorial can be found here: https://github.com/riggaroo/AndroidThings-BlinkingLED

Yay! Accessories arrived. I present to you never seen before footage: a blinking LED 🚨 All powered by #AndroidThings pic.twitter.com/HiHszPqsJf

— Rebecca Franks 📱 (@riggaroo) December 20, 2016

Conclusion

Android Things is an exciting IoT platform to start prototyping with. The ability to access Google APIs on this platform and use the Android development tools (such as Android Studio) is what differentiates this platform from the other IoT platforms. This blog post serves as a starting point for understanding different hardware components and how to start interacting with them with Android Things.

If you liked this blog post, please consider subscribing for more!

Subscribe to Blog via Email

Thanks to @joshliebe and @blundell_apps for reviewing this blog post.