A great test of the contrib drivers is Pimoroni’s Rainbow Hat. https://shop.pimoroni.com/products/rainbow-hat-for-android-things The Rainbow HAT brings together a lot of the components mentioned above on one board. It’s provided with the Android Things Starter Kit so it’s a very good place to start. The first sample I’ve added here focus’s on this specific HAT.
The sample added is based on the google Weather Station sample. It has one difference, it uses Azure Iot Hubs for cloud messaging.
Push Button (A) to swap display from Temperature and Pressure on the board display
Native UI for RaspberryPi to display weather based on air pressure
Telemetry sent from Android Things Device to Azure via Azure Iot Hubs
Message support from Azure to Android Things Device.
To uses the Iot hub in the sample, the DeviceId, DeviceKey and HostName of an Azure Iot hub will need to be provided. I will do a post specific on Iot Hubs to provide more detail on this in subsequent blog posts. These variables are set in the MainActivity.
private bool _useHubs = true; // Set this to true to use Azure Iot Hubs
_weatherDevice.DeviceId = "<Add Azure Iot Hub Device Id Here>";
_weatherDevice.DeviceKey = "<Add Azure Iot Hub Device Key Here>";
_weatherDevice.HostName = "<Add Azure Iot Hub Hostname Here>";
I’m in the process of creating more samples of the rest of the contrib library. I’m also packaging more third-party drivers from around the community into reusable Nuget packages for Android Things with Xamarin.
I’m also having a lot of fun at the moment with a version of these drivers, built from scratch to work with Xamarin Iot. We can then have these components (and Rainbow HAT) working on Linux devices which will of course be awesome!
That was using Xamarin Iot on Visual Studio for the Mac (Preview). Xamarin Iot is also however available for Visual Studio 2017 on Windows (Preview 2.1) too. Below is the identical solution just running from Visual Studio 2017 on Windows. Have a look!
This is just a quick look at Xamarin Iot running on a Raspberry Pi Zero, this time on Visual Studio on Windows. More in-depth content coming soon!
This is a first look at the new Xamarin Iot functionality found within Visual Studio for Mac 7.1 Preview. I will dig much further into detail in future posts, but lets have a very quick look and it. I’m really excited about this addition to the already awesome Xamarin tooling!
A new project type has been added for Iot. This project type or template will create the solution and project needed to run on the Iot device.
What’s immediately apparent is the new run option for the Iot project type. There’s now a new item called “Manage Devices”
The Iot Device Manager allows all the connected devices to be managed. This setup is very similar to the Mac Agent used for iOS development with the Xamarin Visual Studio for Windows extension, however it will display all the Linux based devices running on the network. In this case and screenshot it’s a Raspberry Pi Zero running Raspian (Jesse). Configuring the device will allow remote deploys to the device from your Mac. This will require a user name and password of a user on the Raspberry Pi. This user will be used to connect to the Raspberry pi via SSH. Also note, SSH needs to be enabled on the Raspberry Pi for this to work.
Now you can start developing your Iot solution. What’s really awesome is, all the things you expect to work will just work. This includes break points and a full debugging experience. All this can happen wirelessly to a “headless” device.
The build and execution process is very similar to the Mac Agent when you do iOS development from Windows (Visual Studio) to a Mac. The difference in this case, it is from a Mac (Visual Studio) to a Linux instance (Raspberry Pi). On the very first execution, the mono run time will be copied over to the device. This will be used to execute the built app. The application itself and it’s “built code” is also synchronized with the Raspberry Pi. This compiled Iot app is then in turn executed on the device remotely.
Lets see it in action! Here is a simple example of the now standard Iot demo of a flashing LED, but running on a tiny Raspberry Pi Zero W. What’s really nice about this implementation is, it runs on devices that is not supported by other Iot platforms, like Android Things and Windows 10 Iot Core. It will run on the myriad of Linux based devices out there.
There is much more to show and tell. So there’s much more blogs to come on this topic! This will also include how Android Things and Xamarin Iot can work together to make cross platform Iot simpler.
Android Things is Google’s new IOT Android based platform. In essence it’s a slightly altered version of Android which can run on Iot type devices such as the Intel Edison and the Raspberry Pi3.
“Android Things lets you build professional, mass-market products on a trusted platform, without previous knowledge of embedded system design.”
Personally I’m not yet too impressed with Android Things. It is still very new and very raw and is lacking a lot of what you’d expect from an Iot platform. However, having finally a standard Android implementation officially from Google running on these devices has to be a good thing. The platform should just get better from here.
Running in Visual Studio using Xamarin
Of course being Android, Android Things works with Xamarin too. Using Xamarin will also be a benefit for all those awesome cross platform benefits it offers, like sharing your Iot code with your backend services, Android, Ios, Windows Phone, Windows 10, OSX, XBox and whatever other devices you’d like to be supporting in your solution.
Getting the devices to appear in Visual Studio is exactly as you’d expect. The devices will use the standard Android Debugging Bridge (ADB). Plugging in an Intel Edison via USB will be reflected as “Unknown Iot_Edison”. You can obviously also use the network debugging features of ADB. eg. adb connect <ip address> The device will then also be detected in Visual Studio. A Raspberry Pi will appear as “Unknown iot_rpi3”.
Using Xamarin is very simple. All we need to do is bind to the Android Things API Jar to be able to make use of all the features provided by the Android Things SDK. At this moment in time there isn’t an official release Nuget package from Xamarin to do this. It is however very simple to do this yourself. In this sample (and I’ve shared the code on GitHub) I’m binding to the new Dev Preview 2 API for Android Things (androidthings-0.2-devpreview.jar). Once the binding project is referenced from your Android Things project, everything will work as expected. Just of course with the benefit of using C# and not Java!
I’ve created some samples based on the Standard Android Things Samples
Visual Studio has become a one stop shop for any type of development. But did you know you can do Arduino development as well? There is a Visual Studio extension called Visual Micro (http://www.visualmicro.com) which will allow Arduino development and debugging within Visual Studio IDE, with the full development experience you have become used to. This is a high level overview of what is provided.
What’s really great about having Arduino support within Visual Studio is, you can group together all the various different projects that makes up your solution all together within a Visual Studio Solution.
In a world of Iot and cross platform (or multi platform) development this is perfect. You could have one or more Arduino projects, .NET Micro framework projects, a Xamarin Mobile client and the back-end (be it an on-premise ASP .NET WEB API solution, or in the cloud with something like Azure Mobile Services) all managed together in a single Visual Studio solution.
Installing Visual Micro
Visual Micro can be downloaded here: http://www.visualmicro.com/page/Arduino-Visual-Studio-Downloads.aspx It is a Visual Studio extension which will be installed within Visual Studio. There is a version for both Visual Studio 2015 and 2017 RC. Be sure to have the standard Arduino IDE installed as well, as it uses this tooling under the hood. Arduino version 1.06 – 1.8 is supported.
The IDE Experience
Both a toolbar and a new menu is added to Visual Studio. The toolbar allows access to quickly configure the connected board and COM port used (via USB). It also allows quick access for building and debugging, however if the Arduino project is the startup project the debugging and build options work as usual direct from the Visual Studio hotkeys, toolbars and menu items. The menu allows for deeper configuration of the compiler, debugging options and other integration options.
Templates are provided to easily create a new Arduino Sketch or Library. Standard Arduino INO files are supported. These standard file types are also used when opening and saving to existing Arduino Sketch files, which ofcourse can be ported back to the Arduino IDE if need be.
The solution explorer is quite neat for the Arduino. All the source files, header files and external dependencies are presented in much the way you have grown accustomed to in Visual Studio.
The Visual Micro Explorer provides a visualization of all libraries installed. There is also reference material and documentation provided along with a collection of Example code. This is great for both learning and quickly looking up something.
The live tracing works great. There is also the standard port monitor which does live logging of the Com ports. In the screenshot provided the codes displayed are being reported from an infrared remote control in real-time. The ability to see everything happen, and be visible, at once in an IDE saves a whole load of time.
I’ve been using Visual Micro for a few Arduino related Iot projects and can definitely recommend using it.