Android Things [ADD I2C, PWM examples]

[Luke.go]

Have you ever tried to connect a peripheral device to the GPIO pins on your ODROID SBC with the Android OS? For example, you wished to connect a switch to launch an application or you would wish to connect a dimming sensor. The first problem you will face would be the difficulty to handle the GPIO pins from your Android application or service and maybe you would be faced the permission problems to access a GPIO, PWM or I2C since a general Android application is not denied to access a hardware resource. The alternative solution is to port a low-level library such as wiringPi based on C/C++ but will be burdened to interface to your application through JNI (Java Native Interface) using NDK. Still, you have to figure out the permission problem issue.

Google had introduced yet another OS as known as “Android Things” that is designed to run on light embedded devices and offers the framework with Java to handles peripherals. My idea was to invite the Android Things framework to ODROID and let users use the expansion pins easily. But the problem is that the Android Thing is not open source not like other Android OS therefore I had to implement the code in the Android for ODROID. Fortunately, Google opens the framework APIs with its document and Android Things SDK. This fact encourages me to implement the full stack of the framework that works like what Android Things do from bottom to top.

I use some apis from the Android things’ Peripheral managing parts. Android things has many other features, but that is not needed yet to the odroid. I made interfaces for using android things api. and for processing and managing the request from user layer via API, I build the server and client architecture and connect it to the hardware layer via the wiringPi to control real hardwares. First of all, GPIO, I2C and PWM features are implemented. because people use it more often than other features like spi and uart. Explaining all of the implementation is best, but I will just show you how to use it. that are more useful. I don't want to waste your time.

I made it by reverse engineering. As a result, it can be incompatible and degrade performance. But I expect that users who previously wanted to use GPIO pins on Android will relieve some of the difficulty of working in C or script by my work. Let me show you an example of android things about GPIO, I2C and PWM to learn how to use it.

android_things_diagram.png (71.5 KiB) Viewed 6804 times

[Android Things Implementation Architecture diagram]

There is nothing as simple as using the Android Studio to create, compile, and test an application or service that contains Android Things feature. You just need to install the Android studio, and add official option and official code to use android things, and install a package to odroid via otg port. and just execute a package. It just works! That's all. you don’t need to do anything else.

I uploaded all of the example code to my github repository (https://github.com/xiane/thingsGpioExample). And each of the examples is just separated by branches. On the master branch, You can control the GPIO pin. On the i2c_16x4 branch, you can use 16x4 lcd through I2C. On the PWM branch, you can control the PWM. and on the i2c_weather_board branch, you can use a weatherboard. Please use and test it for your help.

All of the behind code is based on the android thing official site. Please check the official site. https://developer.android.com/things

[Luke.go]

[GPIO]
GPIO Pin Number & Pin map

gpio_pinmap.png (25.51 KiB) Viewed 6758 times

The table is based on the wiki.
https://wiki.odroid.com/odroid-n2/hardw ... _2x20_pins

Before using the Android things, you should add permission for using it. Please add some lines to your project manifest file.

Code: Select all

<uses-permission android:name="com.google.android.things.permission.USE_PERIPHERAL_IO"/>
<uses-library android:name="com.google.android.things"/>

And you should add dependencies to the build.gradle file.

Code: Select all

compileOnly 'com.google.android.things:androidthings:1.0'

First, you should get PeripheralManager. You can get a GPIO instance and available list of GPIO from the manager instance.

Code: Select all

...
import com.google.android.things.pio.PeripheralManager;
import com.google.android.things.pio.Gpio;
…

PeripheralManager manager = PeripheralManager.getInstance();

And you can get an available GPIO list via getGpioList method. This method provides an available GPIO name list. So you can select from the list to use. Each pin has a name that comes from a physical pin number. yes, GPIO pin name is pin number. You can get GPIO instance through oepnGpio method with pin name by parameter.

Code: Select all

...
List<String> gpioList = manager.getGpioList();

Gpio gpio = manager.openGpio(gpioList.get(0));
// or Gpio gpio = manager.openGpio(“7”);
...

In this example, I will introduce how to use a GPIO pin as an output. In the example, I want to use pin #7 as output and if I push the button of application, led that connected to GPIO pin #7 will be lighting. Like above, after getting a GPIO instance, you can set the direction IO of the GPIO pin. You can set direction by setDirection method and direction values are DIRECTION_IN, DIRECTION_OUT_INITIALLY_HIGH and DIRECTION_OUT_INITIALLY_LOW. I chose DIRECTION_OUT_INITIALLY_LOW to make GPIO value low.
Then you can set value via the setValue method. If you want to make output value too high or 1, You should pass the True parameter. or not, you pass the false parameter as low or 0.
In this example, I get input from the application's button. So when you click the button a led light.

Code: Select all

…
gpio.setDirection(Gpio.DIRECTION_OUT_INITIALLY_LOW);
Switch gpioSwitch = find ViewById(R.id.gpio_switch);

gpioSwitch.setOnClickListener(new View.OnClickListener() {
	@Override
	public void onClick(View v) {
		try {
			Switch gpioSwitch = (Switch) v;
			if (gpioSwitch.isChecked()) {
				gpio.setValue(true);

			} else {
				gpio.setValue(false);
			}
		} catch (IOException io) {
			io.printStackTrace();
		}
	}
});
…

The Android Things also provide other many methods like getValue, setActiveType, setEdgeTriggerType and registerGpioCallback. You can learn about it from the official web page. However, The odroid still does not provide registerGpioCallback properly. In particular, Callback configuration using Handler has not been implemented yet. I hope it is implemented.

GPIO method reference - https://developer.android.com/reference ... s/pio/Gpio

+EDITED: Add manifest line for adding permission.

[Luke.go]

things_gpio_out_example_bb.png (252.41 KiB) Viewed 6776 times

[GPIO OFF]

Screenshot_20191211-091410.png (59.87 KiB) Viewed 6776 times

IMG-1724.jpg (350.84 KiB) Viewed 6776 times

[GPIO ON]

Screenshot_20191211-091418.png (64.08 KiB) Viewed 6776 times

IMG-1725.jpg (349.94 KiB) Viewed 6776 times

You can control I2C and PWM like this way. Please check an example from my github. Also you can learn about each peripheral api from web site.

I2C - https://developer.android.com/things/sdk/pio/i2c
PWM - https://developer.android.com/things/sdk/pio/pwm

I hope it will help you use the peripherals easily!

[rooted]

Wow this is very promising work, I look forward to trying this out over the Christmas holidays.

This is going to really make Android more serviceable for makers!

[joerg]

Hello Luke.go,
first of all let me say that it is very impressive what you have done.
Sadly I cannot open the peripheral manager. I have made an initial app, only try to open the gpio list. The app compiles, but I get this error right after start:

Code: Select all

java.lang.NoClassDefFoundError: Failed resolution of: Lcom/google/android/things/pio/PeripheralManager

I guess that the permission <uses-permission android:name="com.google.android.things.permission.USE_PERIPHERAL_IO" /> is unknown. Android shows that are no premissions are used by my app.
Could it be that your reverse engineered libraries of Android Things are missing?

[Luke.go]

@joerg, I added USE_PERIPHERAL_IO permission.
And, you should use the latest android img of odroid-N2.
I did nothing for other board yet.

[Luke.go]

Oh, Before do above the my example, you should add belows to your manifest.

<uses-permission android:name="com.google.android.things.permission.USE_PERIPHERAL_IO"/>
<uses-library android:name="com.google.android.things"/>
like this -> https://github.com/androidthings/sample ... nifest.xml

and you shuold add dependencies to a build.gradle file.
compileOnly 'com.google.android.things:androidthings:1.0'

please check my example repos.

[joerg]

OK. Thank you.
Yes I looked at your manifest already. But right now I can't try again, I'm on buisness trip.
At weekend I will try.

[joerg]

Hello @Luke.go,
yes, this was missing in my manifest:

Code: Select all

<uses-library android:name="com.google.android.things"/>

Inputs and outputs are working.
But I tried to assign interrupt callback to the inputs, without success. I assume that it is not implemented yet?

[Luke.go]

Hello @Luke.go,
yes, this was missing in my manifest:

Code: Select all

<uses-library android:name="com.google.android.things"/>

Inputs and outputs are working.
But I tried to assign interrupt callback to the inputs, without success. I assume that it is not implemented yet?

Did you teste registerGpioCallback(GpioCallback parameter) method?
It maybe work. But with Handler parameter, it doesn't.

[Luke.go]

Hello @Luke.go,
yes, this was missing in my manifest:

Code: Select all

<uses-library android:name="com.google.android.things"/>

Inputs and outputs are working.
But I tried to assign interrupt callback to the inputs, without success. I assume that it is not implemented yet?

Did you teste registerGpioCallback(GpioCallback parameter) method?
It maybe work. But with Handler parameter, it doesn't.

I hope that next version fixed the problem.

[joerg]

Hello Luke.go,
sadly I can't try it further. I've made from the N2 an All-In-One PC for my 11y old daughter. She is happy.

Would it be a big work to port Android Things to the C2 Marshmallow? If you give me a hint where to find your ported libraries, I could try it by myself.

And this is the code I tried, it never was called from interrupt:

Code: Select all

    private GpioCallback gpioCallback = new GpioCallback() {
        @Override
        public boolean onGpioEdge(Gpio gpio) {
            // Read the pin state
            final String strGpio = gpio.getName();
            Log.i(TAG, "GPIO changed, " + strGpio);
            try {
                if (gpio.getValue()) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            CheckBox cb = findViewById(Integer.valueOf(strGpio) + 10000);
                            if (cb != null) cb.setChecked(true);
                        }
                    });
                } else {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            CheckBox cb = findViewById(Integer.valueOf(strGpio) + 10000);
                            if (cb != null) cb.setChecked(false);
                        }
                    });
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            // Continue listening for more interrupts
            return true;
        }

        @Override
        public void onGpioError(Gpio gpio, int error) {
            Log.w(TAG, gpio + ": Error event " + error);
        }
    };

And this to setup the gpio:

Code: Select all

           gpio = manager.openGpio(strGpio);
           gpio.setDirection(Gpio.DIRECTION_IN);
           gpio.setActiveType(Gpio.ACTIVE_HIGH);
           gpio.setEdgeTriggerType(Gpio.EDGE_BOTH);
           gpio.registerGpioCallback(gpioCallback);

[mad_ady]

I've made from the N2 an All-In-One PC for my 11y old daughter. She is happy.

Sorry for the offtopic, but I'd like to know more. What OS are you using and what is she mostly using it for? Web apps? What about gaming requirements, or isn't she into gaming?

[Luke.go]

Hello Luke.go,
sadly I can't try it further. I've made from the N2 an All-In-One PC for my 11y old daughter. She is happy.

Would it be a big work to port Android Things to the C2 Marshmallow? If you give me a hint where to find your ported libraries, I could try it by myself.

And this is the code I tried, it never was called from interrupt:

Code: Select all

    private GpioCallback gpioCallback = new GpioCallback() {
        @Override
        public boolean onGpioEdge(Gpio gpio) {
            // Read the pin state
            final String strGpio = gpio.getName();
            Log.i(TAG, "GPIO changed, " + strGpio);
            try {
                if (gpio.getValue()) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            CheckBox cb = findViewById(Integer.valueOf(strGpio) + 10000);
                            if (cb != null) cb.setChecked(true);
                        }
                    });
                } else {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            CheckBox cb = findViewById(Integer.valueOf(strGpio) + 10000);
                            if (cb != null) cb.setChecked(false);
                        }
                    });
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            // Continue listening for more interrupts
            return true;
        }

        @Override
        public void onGpioError(Gpio gpio, int error) {
            Log.w(TAG, gpio + ": Error event " + error);
        }
    };

And this to setup the gpio:

Code: Select all

           gpio = manager.openGpio(strGpio);
           gpio.setDirection(Gpio.DIRECTION_IN);
           gpio.setActiveType(Gpio.ACTIVE_HIGH);
           gpio.setEdgeTriggerType(Gpio.EDGE_BOTH);
           gpio.registerGpioCallback(gpioCallback);

Yeah.. that is bug.
I can reproduce that, and I also can't make interrupt.

You can make it work with EDGE_RISING or EDGE_FALLING.
And... that works like EDGE_BOTH.

[Luke.go]

Hello Luke.go,
sadly I can't try it further. I've made from the N2 an All-In-One PC for my 11y old daughter. She is happy.

Would it be a big work to port Android Things to the C2 Marshmallow? If you give me a hint where to find your ported libraries, I could try it by myself.

And this is the code I tried, it never was called from interrupt:

Code: Select all

    private GpioCallback gpioCallback = new GpioCallback() {
        @Override
        public boolean onGpioEdge(Gpio gpio) {
            // Read the pin state
            final String strGpio = gpio.getName();
            Log.i(TAG, "GPIO changed, " + strGpio);
            try {
                if (gpio.getValue()) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            CheckBox cb = findViewById(Integer.valueOf(strGpio) + 10000);
                            if (cb != null) cb.setChecked(true);
                        }
                    });
                } else {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            CheckBox cb = findViewById(Integer.valueOf(strGpio) + 10000);
                            if (cb != null) cb.setChecked(false);
                        }
                    });
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            // Continue listening for more interrupts
            return true;
        }

        @Override
        public void onGpioError(Gpio gpio, int error) {
            Log.w(TAG, gpio + ": Error event " + error);
        }
    };

And this to setup the gpio:

Code: Select all

           gpio = manager.openGpio(strGpio);
           gpio.setDirection(Gpio.DIRECTION_IN);
           gpio.setActiveType(Gpio.ACTIVE_HIGH);
           gpio.setEdgeTriggerType(Gpio.EDGE_BOTH);
           gpio.registerGpioCallback(gpioCallback);

Yeah.. that is bug.
I can reproduce that, and I also can't make interrupt.

You can make it work with EDGE_RISING or EDGE_FALLING.
And... that works like EDGE_BOTH.

Please test it with updating dtbs files

meson64_odroidn2_android.zip

(18.8 KiB) Downloaded 57 times

[Luke.go]

[I2C]
Available I2C Table

I2C_pintable.png (5.72 KiB) Viewed 5949 times

You can also use I2C on the ODROID board with Android things. You can use any I2C API provided by the Android things. The Android Things supports various sizes of data transmission, byte, word and buffered data.

I ported the Weather board 2(https://www.hardkernel.com/product-category/sensor/) example to Android with Android things. Also I ported I2C display(https://www.hardkernel.com/product-category/display/).
Like other familiar I2C devices, both of above devices are connected with 4 wires, Voltage, Ground, I2C SDA and I2C SCL. In the examples, I connected I2C wires to the I2C-2.

[Weather Board 2 Diagram]

weather_board_n2.png (186.17 KiB) Viewed 5949 times

[I2C LCD Diagram]

odroid-n2-i2c-lcd.png (58.75 KiB) Viewed 5949 times

Most of pre-procedure are same to GPIO procedure. Add permission to the manifest, import and call the instance of PeripheralManager to the project source code. But you do not need to get a GPIO instance. You need to call the openI2cDevice method to get the I2C device instance.

Code: Select all

...
List<String> i2cBusList = manager.getI2cBusList();

I2cDevice device  = manager.openI2cDevice(i2cBusList.get(0), I2C_DEVICE_ADDRESS);
// or i2cDevice device = manager.openI2cDevice(“I2C-2”, I2C Device Address);
…

The I2C Interface names are I2C-2 and I2C-3. Each I2C interface consists of pins 3,5 and pins 27, 28. When you get the I2C bus device, you should set the I2C device address for each I2C chip. In this case, a weather board2 is consist of two I2C chip. so I create two I2C device instance. One instance is linked by 0x76 to the BME280. The chip offers temperature, pressure and humidity values. And the other instance is linked by 0x60 to the SI1132. The chip offers UV, Visible and IR values. And I2C LCD has one I2C chip, so I create one I2C instance. It linked by 0x27 for control the LCD. Like this, you should create I2C device instance for the each device with their own address.

Through the I2C instance, you can communicate with the device. Android things provide many methods. For reading the data from a device, it provide read, readRegBuffer, readRegByte and readRegWord method. Also for writing data to device, it provide write, writeRegBuffer, writeRegByte and writeRegWord.
The Android Things official website provides a lot of information.

I2C Device method reference -
https://developer.android.com/reference ... ce#summary

By using the I2C API, I build a wrapper class for weather board2 and I2C LCD. Here is a part of the example code to read and write data with the Android things API.

Code: Select all

…
private void softrst() throws IOException {
	device.writeRegByte(reg.RST, POWER_MODE.SOFT_RESET_CODE);
}

private byte getPowerMode() throws IOException {
	return (byte) (device.readRegByte(reg.CTRL_MEAS) & 0b11);
}
...

The code is part of BME280.java. First method is called to soft reset the chip and second method is called to get chip’s power mode. Each API’s first parameter is address of register in the chip. On the write method, second parameter is usually the data to transfer. also on the read method, second parameter is usually not exist. But if you want to read data by buffer, you need buffer to read and the buffer is passed as a second parameter.

You can test or use the project. Here is the link.

Weather board2 with android things example - https://github.com/xiane/thingsGpioExam ... ther_board

I2C LCD with android things example - https://github.com/xiane/thingsGpioExample/tree/i2c_lcd

[Luke.go]

[Weather board 2 Hardware connection]

wb2_a_things.jpg (478.33 KiB) Viewed 5948 times

[weather board 2 Output Result]

Screenshot_20200106-045534.png (84.54 KiB) Viewed 5948 times

[I2C LCD hardware connection and result]

i2c_lcd_1.jpg (310.58 KiB) Viewed 5948 times

i2c_lcd_2.jpg (309.54 KiB) Viewed 5948 times

[Luke.go]

PWM

Available PWM Table

PWM_pintable.png (3.99 KiB) Viewed 5947 times

The android Things also support the PWM. There is many methods to configure and control the PWM interface. You can set the PWM Frequency via setPwmFrequency. Before enabling the pin, you must set frequency via this method. Also you can set PWM duty cycle by setPwmDutyCycle between 0 and 100. Frequency and duty cycle settings can be set in both enabled and disabled state and will be remembered.
Please check the Reference.
https://developer.android.com/things/sdk/pio/pwm

Here is PWM testing project. In this example, you can turn on and off a PWM pin. and change duty cycle via progress bar on the Application.
https://github.com/xiane/thingsGpioExample/tree/pwm

[PWM OFF state]

Screenshot_pwm_off.png (61.07 KiB) Viewed 5947 times

pwm_led_off.jpg (358.99 KiB) Viewed 5947 times

pwm_led_scope_off.jpg (462.68 KiB) Viewed 5947 times

[Luke.go]

[PWM ON 50%]

Screenshot_pwm_on_2.png (65.84 KiB) Viewed 5947 times

pwm_led_on_2.jpg (357.18 KiB) Viewed 5947 times

pwm_led_scope_on_2.jpg (453.76 KiB) Viewed 5947 times

[Luke.go]

[PWM ON 100%]

Screenshot_pwm_on_3.png (62.69 KiB) Viewed 5947 times

pwm_led_on_3.jpg (363.98 KiB) Viewed 5947 times

pwm_led_scope_on_3.jpg (475.38 KiB) Viewed 5947 times

[kafan1986]

@Luke I am currently using one of the 5V pin and Ground pin to light some LEDs, which gets switched on when the system gets powered ON. Now, I am planning to move the LEDs, so that they can be controlled within the app using your framework. Can you tell me the output voltage of GPIO pins? Is it 5V or 3.3V?

[tobetter]

@Luke I am currently using one of the 5V pin and Ground pin to light some LEDs, which gets switched on when the system gets powered ON. Now, I am planning to move the LEDs, so that they can be controlled within the app using your framework. Can you tell me the output voltage of GPIO pins? Is it 5V or 3.3V?

The voltage at GPIO pins on ODROID-N2 are all 3.3V

[FntX]

Sorry for asking but I'm a little bit confused. Does that mean we now can access and use the android things API from inside the full fledged android OS?

[rooted]

Sorry for asking but I'm a little bit confused. Does that mean we now can access and use the android things API from inside the full fledged android OS?

Yes

[FntX]

Sorry for asking but I'm a little bit confused. Does that mean we now can access and use the android things API from inside the full fledged android OS?

Yes

Great!
What a time to be alive. This opens a truckload of possibilities!

[Luke.go]

Sorry for asking but I'm a little bit confused. Does that mean we now can access and use the android things API from inside the full fledged android OS?

You can use Peripheral I/O APIs of the android things except SPI and UART.
This 2 kind of peripherals are not implemented yet.
AND It just work on ODROID-N2.