For the purposes of this chapter, you will need the following:

• A Raspberry Pi 2 or 3 (you'll need three in total, throughout the book)
• A micro SD memory card (16 GB or greater) for each Raspberry Pi
• A shielded box, to avoid electrostatic damage to your device
• A laptop or PC running Windows 10, where you can insert the memory card
• An Ethernet network cable, if you use Raspberry Pi 2 or lack Wi-Fi
• An internet connection

The Raspberry Pi 2 or 3 will allow us to run .NET applications and control peripherals using digital input and output easily. It's also a great platform for creating connected distributed services. One of its weaknesses, however, is its lack of simple out-of-the-box analog interfaces. To do analog input and output, you must connect additional chips or equipment using either synchronous or asynchronous serial communication interfaces that converts analog signals to digital ones. To simplify this task, you can also use an Arduino board that you connect to the Raspberry Pi via USB. This has the added benefit of allowing you to use a wide range of standard Arduino peripherals and devices in your Raspberry Pi projects. So, you need to add to your list:

• Arduino shield for Raspberry Pi B+/2B/3B
• Short serial USB cable to connect the Arduino board to the Raspberry Pi
• Analog Arduino-compatible light sensor
• Digital motion detection PIR sensor
• Digital relay module

Most of the above equipment (and more) can be obtained in so-called Starter Kits. Such starter kits make for great fun, since they often include a wide variety of sensors and actuators for you to play with. For examples, refer to https://www.dfrobot.com/category-173.html.

Installing Windows 10 on a Raspberry Pi is both free and very easy. Microsoft has developed a tool for this purpose: the IoT Dashboard. Apart from allowing you to download and install Windows 10 on your devices, it also helps you manage your devices in the network. It's a very handy tool, and does not require you to learn any command-line syntax:

The IoT Dashboard is a Windows 10 app. Once running, you can choose to right-click on its icon and select Pin to taskbar, so that you can find it easier later.

If you don't want to use Windows 10, and want to use Linux instead, you can do so with the following modifications:

• You can use the Raspbian operating system instead. It's based on Debian. Follow the following instructions on how to download and install it: https://www.raspberrypi.org/documentation/installation/installing-images/.
• Instead of compiling your project as a .NET Core application, compile it as a standard .NET Framework application instead.
• Run the application using Mono. You can follow the following instructions on how to accomplish this: http://www.raspberry-sharp.org/eric-bezine/2012/10/mono-framework/installing-mono-raspberry-pi/.

When you've installed and run the IoT Dashboard, a window appears:

1. Select Set up a new device in the left-hand menu. This will open a simple form. Select your device (Raspberry Pi 2 & 3) and the OS you want to download and install (Windows 10 IoT Core).

2. Also, insert the memory card into the computer and select the Drive letter it is assigned to. Other relevant information you need to provide include the Device name and an Administrator password:

3. If you have access to Wi-Fi (2.4 GHz), and are programming a device with access to Wi-Fi, make sure the correct Wi-Fi Network Connection is also assigned:

4. Finally, accept the license agreement, and press the Download and install button:

You need to confirm you really want to format the memory card, and install Windows 10 on it. All previous data on the card will be lost. The IoT Dashboard then goes on to download the operating system and preparing the memory chip for you, including configuring the device, according to the settings you provided. This process includes performing some command-line tasks, so you will see a terminal window appear temporarily.

When the card is ready, an Explorer window might appear, and the IoT Desktop window gives you instructions to remove the card and insert it into your device. Do so, and make sure you connect your device correctly. Then power it on. Meanwhile, go to the My Devices view in the IoT Dashboard. It might take a short while to boot the device up the first time. Don't worry, after first-time initialization, your Raspberry Pi, with Windows 10, should appear. This process can take from a couple of minutes to a quarter of an hour, depending on the memory card used:

When the device appears in your list of devices, right-click on it, and select Open in Device Portal. Your browser should open and prompt you to login. The username is Administrator. Enter the password you provided when you prepared your memory chip.

The Device Portal is a very handy and powerful web portal for your device. In it you can:

• Configure basic device settings (you should update your time zone at this point).
• Update your password.
• Remotely view what's on the screen. This will come in handy, especially for devices that are not connected to monitors. Press the Capture Screenshot button to try this out.
• Control installed apps.
• Access files.
• View processes and system performance.
• Access a command prompt.
• Access debugging tools.
• Control system devices.
• Manage network connectivity.
• Update Windows (make sure you have the latest version by clicking on the Check for updates button):

In projects where you want to use the Arduino in conjunction with the Raspberry Pi, you typically use an Arduino board that is mounted on top of the Raspberry Pi. This board also needs to be prepared. You do this using the Arduino IDE software, which can be downloaded from this link: https://www.arduino.cc/en/Main/Software. There are setup applications for Windows, Linux, and MAC.

To access analog sensors on a Raspberry Pi, you need to add circuitry supporting serial communication to your board since it's not supported by default. One way is to use I²C or SPI circuits with analog to digital converters. Another way, which we explore in this book, is to use an Arduino board. The Arduino is a programmable chip, and, as such, you can program your own firmware with your own serial protocol inside. A simpler method, is to use the well-used and battle-tested Firmata protocol. Software for this already exists, and is available in the Arduino IDE directly. Libraries for Firmata exist in many languages.

To install Firmata on your Arduino board, simply follow the following procedure:

1. Connect your Arduino board to your PC using a short USB cable.
2. Load the Firmata application into the IDE. This is done by selecting File, then Examples, Firmata and Standard Firmata from the menu in the Arduino IDE.
3. Specify the serial port you connected the Arduino board to. This is done under Tools and Port in the Arduino IDE.

4. Next you need to specify the type of Arduino you're using. If using an Arduino Starter Kit, the name should be listed in the specification. You select the board under Tools and Board in the Arduino IDE.
5. Finally, you upload the firmware to the Arduino board. You do this by clicking on the Upload button, formed as an arrow.

Your Arduino board is now prepared with the Firmata firmware. You can close the Arduino IDE. You will not use it any more in this book.

Without disconnecting your Arduino board from your PC, you can test that it works as it should. Since the Firmata protocol is well known, there exist a lot of applications on varying operating systems, that can read sensors and control devices connected to the Arduino. Since we demonstrate Windows 10 in this book, you can use the Windows Remote Arduino Experience App for this purpose. It can be downloaded at https://www.microsoft.com/sv-se/store/p/windows-remote-arduino-experience/9nblggh2041m.

To test this software, we also need to connect some devices to it for testing. Let's connect our light sensor, PIR sensor, and relay module to it to see if we can access them. Make sure to connect ground, power and signal correctly. Also make sure to differentiate between digital pins and analog pins on your Arduino board. For the purposes of our example, I connected the PIR sensor to digital pin 8, and the relay to digital pin 9. The light sensor was connected to the analog pin A0.

When opening the Windows Remote Arduino Experience App, you must first choose how the app will communicate with your Arduino board. Since it's connected to a USB port, select USB in the Connection box, and select a communication speed of 57600 baud. Next, the app makes a search, and a list of devices will be presented. The Arduino board should appear. Select it and click the Connect button.

You should now be able to interact with the hardware you connected. First go to the Analog tab. Set the A0 pin to Input, and then watch how the value changes as you cover or illuminate the sensor accordingly:

Similarly, on the Digital tab, set the 8 pin to Input. Move your hand in front of the PIR sensor to activate it, and watch how the value jumps to a high voltage level. Set the 9 pin to Output and control it by setting the value correspondingly. You should hear the relay clicking as it changes position:

Now that you know your Arduino is programmed correctly, and that values are reported as they should be over the USB serial cable, you're ready to start programming.

You're now ready to start actual coding. The first step is to choose a development environment. Since this book focuses on C# and .NET, including .NET Core 2, an obvious choice is to use Visual Studio. But it's not your only option.

For .NET Core development, you can also choose to use Roslyn, which, apart from being open source, can also be run directly on Windows 10 IoT Core, including the version we use on the Raspberry Pi. For more information about Roslyn, see https://msdn.microsoft.com/magazine/mt808499.

Another option, is to use Xamarin Studio. It's a development tool focusing on cross platform development using C#. With Xamarin you can develop applications for IoT devices, smart phones and tablets, as well as PCs using the same code base. It runs on both Windows and MAC. The community-edition is free. For more information, see https://www.xamarin.com/studio.

Since Microsoft acquired Xamarin, its cross-platform capabilities are also available in Visual Studio. A free version also exists. And Visual Studio can be run on MACs. The examples published in this book have been developed using Visual Studio 2017. For more information, see https://www.visualstudio.com/.

The projects presented in this book are all available on GitHub at https://github.com/PeterWaher/MIoT. To simplify development and prototyping, these projects use several libraries. These are available as downloadable and updateable packages (NuGets), most of which are open source, available on GitHub in the IoT Gateway repository at https://github.com/PeterWaher/IoTGateway. The IoT Gateway repository is available free for personal or academic use, or for security analysis. Commercial use requires a commercial license. The repository includes communication libraries, an encrypted object database, event logging infrastructure, application hosting, web server, content management, scripting, runtime-tools, and so on. Things that are good to have, to prototype real-world embedded IoT applications easily and quickly.

Let's begin. Since our Raspberry Pi now runs Windows 10 IoT Core, .NET Core applications will run on it, including Universal Windows Platform (UWP) applications. From a blank solution, let's create our first Raspberry Pi application. Choose Add and New Project. In the Visual C# category, select Blank App (Universal Windows). Let's call our project FirstApp. Visual Studio will ask us for target and minimum platform versions. Check the screenshot and make sure the version you select is lower than the version installed on your Raspberry Pi.

In the Solution Explorer, we should now see the files of our new UWP project:

We proceed by adding functionality to our app from downloadable packages, or NuGets. From the References node, right-click and select Manage NuGet Packages. First, go to the Updates tab and make sure the packages that you already have are updated. Next, go to the Browse tab, type Firmata in the search box, and press Enter. You should see the Windows-Remote-Arduino package. Make sure to install it in your project. In the same way, search for the Waher.Events package and install it.

Since we're going to communicate with our Arduino using a USB serial port, we must make a declaration in the Package.appxmanifest file stating this. If we don't do this, the runtime environment will not allow the app to do it. Since this option is not available in the GUI by default, you need to edit the file using the XML editor. Make sure the serialCommunication device capability is added, as follows:

<Capabilities> 
   <Capability Name="internetClient" /> 
   <DeviceCapability Name="serialcommunication"> 
         <Device Id="any"> 
               <Function Type="name:serialPort" /> 
         </Device> 
   </DeviceCapability> 
</Capabilities> 

Before we do any communication with the Arduino, we need to initialize the application. We do this by finding the OnLaunched method in the App.xml.cs file. After the Window.Current.Activate() call, we make a call to our Init() method where we set up the application.

   Window.Current.Activate(); 
   Task.Run((Action)this.Init); 

We'll make the method asynchronous:

private async void Init() 
{ 
   try 
   { 
         Log.Informational("Starting application."); 
         ... 
   } 
   catch (Exception ex) 
   { 
         Log.Emergency(ex); 
          
         MessageDialog Dialog =  
new MessageDialog(ex.Message, "Error"); 
         await Dialog.ShowAsync(); 
} IoT Desktop  
} 

The static Log class is available in the Waher.Events namespace, belonging to the NuGet we included earlier. (MessageDialog is available in Windows.UI.Popups, which might be a new namespace if you're not familiar with UWP.)

The Arduino is accessed using Firmata. To do that, we use the Windows.Devices.Enumeration, Microsoft.Maker.RemoteWiring, and Microsoft.Maker.Serial namespaces, available in the Windows-Remote-Arduino NuGet. We begin by enumerating all the devices it finds:

DeviceInformationCollection Devices =  
   await UsbSerial.listAvailableDevicesAsync(); 
foreach (DeviceInformationDeviceInfo in Devices) 
{ 

If our Arduino device is found, we will have to connect to it using USB:

if (DeviceInfo.IsEnabled&&DeviceInfo.Name.StartsWith("Arduino")) 
{ 
   Log.Informational("Connecting to " + DeviceInfo.Name); 
 
   this.arduinoUsb = new UsbSerial(DeviceInfo); 
   this.arduinoUsb.ConnectionEstablished += () => 
         Log.Informational("USB connection established."); 

Attach a remote device to the USB port class:

this.arduino = new RemoteDevice(this.arduinoUsb); 

We need to initialize our hardware, when the remote device is ready:

this.arduino.DeviceReady += () => 
{ 
   Log.Informational("Device ready."); 
 
   this.arduino.pinMode(13, PinMode.OUTPUT);    // Onboard LED. 
   this.arduino.digitalWrite(13, PinState.HIGH); 
 
   this.arduino.pinMode(8, PinMode.INPUT);      // PIR sensor. 
   MainPage.Instance.DigitalPinUpdated(8,
          this.arduino.digitalRead(8)); 
   this.arduino.pinMode(9, PinMode.OUTPUT);     // Relay. 
   this.arduino.digitalWrite(9, 0);             // Relay set to 0 
 
   this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor. 
   MainPage.Instance.AnalogPinUpdated("A0",
          this.arduino.analogRead("A0")); 
}; 

Our inputs are then reported automatically by the Firmata firmware. All we need to do to read the corresponding values is to assign the appropriate event handlers. In our case, we forward the values to our main page, for display:

this.arduino.AnalogPinUpdated += (pin, value) => 
{ 
   MainPage.Instance.AnalogPinUpdated(pin, value); 
}; 
 
this.arduino.DigitalPinUpdated += (pin, value) => 
{ 
   MainPage.Instance.DigitalPinUpdated(pin, value); 
}; 

Communication is now set up. If you want, you can trap communication errors, by providing event handlers for the ConnectionFailed and ConnectionLost events. All we need to do now is to initiate communication. We do this with a simple call:

this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1); 

Make sure the Arduino is still connected to your PC via USB. If you run the application now (by pressing F5), it will communicate with the Arduino, and display any values read to the event log. In the GitHub project, I've added a couple of GUI components to our main window, that display the most recently read pin values on it. It also displays any event messages logged. We leave the relay for later chapters.

You are now ready to test the app on the Raspberry Pi. You now need to disconnect the Arduino board from your PC, and install it on top of the Raspberry Pi. The power of the Raspberry Pi should be turned off when doing this. Also make sure the serial cable is connected to one of the USB ports of the Raspberry Pi. Begin by switching the target platform, from Local Machine to Remote Machine, and from x86 to ARM:

Your Raspberry Pi should appear automatically in the following dialog. You should check the address with the IoT Dashboard used earlier, to make sure you're selecting the correct machine:

You can now run or debug your app directly on the Raspberry Pi, using your local PC. The first deployment might take a while, since the target system needs to be properly prepared. Subsequent deployments will be much faster. Open the Device Portal from the IoT Dashboard, and take a Screenshot, to see the results. You can also go to the Apps Manager in the Device Portal, and configure the app to be started automatically at startup:

In this chapter, you've been given an introduction on how to develop apps for the Raspberry Pi using C#. You've learned how to prepare the hardware and how to use the IoT Dashboard to install and configure Windows 10 IoT on the device. You've used the Device Portal to control the applications running on it. You've learned how to extend the functionality of the Raspberry Pi by using Arduino boards. You've configured these with Firmata using the Arduino IDE. You've learned how to create a Universal Windows Platform application to run on the Raspberry Pi, and how to use NuGet packages to add existing software components to your application. You also successfully tested and deployed your application. In the next chapter, you will learn the basics of creating a working sensor.