New Project

Since you are using C++ for the active project (called the startup project ), you use the Blank App (Universal Windows) template under the C ++ ➤ Windows ➤ Universal category. Use the name Weather for the project name. You can save the project wherever you like or use the default location.

Add a C# Runtime Component Project

With the Weather C++ project open, right-click the solution and choose Add ➤ New Project…. For this project, you want a C# Runtime Component project. Use the Other Languages ➤ C# ➤ Windows ➤ Universal ➤ Windows Runtime Component template. Name the project WeatherSensor. You can save the project wherever you like or use the default location.

What you should see at this point is one solution entitled Solution ‘Weather’ with two projects: Weather and Weather Sensor. The Weather project is the startup project. Figure 12-2 shows an example of what you should see in the Solution Explorer. If the Weather project is not the startup project, you can right-click it and set it as the startup project.

Figure 12-2. Solution Explorer with Weather and WeatherSensor projects

At this point, you have the projects created but you still must add the code for the BMP280 class, add references for the projects, the user interface, and code to read the sensor and display it in the user interface.

BMP280 Class

You are going to use the Adafruit code in our project. If you haven’t downloaded the sample project, do that now. You need the file named BMP280.cs. To add it to the project, right-click the WeatherSensor project and choose Add ➤ Existing Item… then browse for the file and select it. Visual Studio copies the file to your project folder.

You will have to edit this file because it is not in the correct state for use in a runtime component project. But first, you can delete the Class1.cs file that the template provided. You do not need it. Simply right-click the file and choose Delete.

The modifications you need to make include changes to the class decorations and some of the methods. You want to allow the code to read from the sensor to run as a task, however, the code as written won’t work. You must start the tasks from inside the project rather than from other code as it was originally written. You will change the following things. I go through each of them in turn. As you will see, the changes aren’t complex but they are required for the C# project to be used with the C++ project .

• Class declarations must be sealed

• The Initialize() method must run the set up code as a task

• The Read* methods must be normal methods that run the Begin() code as a task

Let’s begin with changes to the classes. Open the BMP280.cs file. You see two classes: BMP280_CalibrationData and BMP280. Change the class declaration to a sealed class, as shown in Listing 12-1. This is an excerpt of the affected code for brevity and adjacent lines to show context.

Listing 12-1. Changes to the Class Declarations

...
 using Windows.Devices.Gpio;
 using Windows.Devices.I2c;
-namespace Lesson_203
+namespace WeatherSensor
 {
-    public class BMP280_CalibrationData
+    public sealed class BMP280_CalibrationData                  
     {
         //BMP280 Registers
         public UInt16 dig_T1 { get; set; }

...

         public Int16 dig_P9 { get; set; }
     }
-    public class BMP280
+    public sealed class BMP280                  
     {
         //The BMP280 register addresses according the the datasheet: http://www.adafruit.com/datasheets/BST-BMP280-DS001-11.pdf
         const byte BMP280_Address = 0x77;
...

Next, you must change the Initialize() method to call a new Setup() method as a task. Listing 12-2 shows the changes needed for that method.

Listing 12-2. Changes to the Initialize() Method

         //Method to initialize the BMP280 sensor
-        public async Task Initialize()
+        public void Initialize()                
         {
             Debug.WriteLine("BMP280::Initialize");
+            Task t_setup = Task.Run(() => Setup());                
+            t_setup.Wait();                
+        }                
+                
+        private async Task Setup()                
+        {                
+            Debug.WriteLine("BMP280::Setup");                
...

You are splitting the set up code out as a separate method decorated to run as an asynchronous task. This is necessary to ensure that the code does not run in the same thread as the user interface (it can’t).

Next, you must change the ReadTemperature() method to remove the async decorator and to call the Begin() method as a task. This protects the thread and ensures that the code executes outside of the user interface thread. Listing 12-3 shows the changes needed.

Listing 12-3. Changes to the ReadTemperature() Method

...
-        public async Task<float> ReadTemperature()
+        public float ReadTemperature()                
         {
             //Make sure the I2C device is initialized
-            if (!init) await Begin();
+            if (!init)                
+            {                
+                Task t_begin = Task.Run(() => Begin());                
+                t_begin.Wait();                
+            }                
...

You must change the ReadPressure() method in the same manner as ReadTemperature(). However, since this method must call ReadTemperature() and it is no longer a task, you can call the method directly. Listing 12-4 shows the changes needed.

Listing 12-4. Changes to the ReadPressure() Method

...
-        public async Task<float> ReadPreasure()
+        public float ReadPreasure()                
         {
             //Make sure the I2C device is initialized
-            if (!init) await Begin();
+            if (!init)                
+            {                
+                Task t_begin = Task.Run(() => Begin());                
+                t_begin.Wait();                
+            }                
             //Read the temperature first to load the t_fine value for compensation
             if (t_fine == Int32.MinValue)
             {               
-                await ReadTemperature();
+                ReadTemperature();                
             }
...                                                                                          

Finally, you must change the ReadAltitude() method in the same manner. Listing 12-5 shows the changes needed.

Listing 12-5. Changes to the ReadAltitude() Method

...
-        public async Task<float> ReadAltitude(float seaLevel)
+        public float ReadAltitude(float seaLevel)                
         {
             //Make sure the I2C device is initialized
-            if (!init) await Begin();
+            if (!init)                
+            {                
+                Task t_begin = Task.Run(() => Begin());                
+                t_begin.Wait();                
+            }                
             //Read the pressure first
-            float pressure = await ReadPreasure();
+            float pressure = ReadPreasure();                
             //Convert the pressure to Hectopascals(hPa)
             pressure /= 100;
...

That’s it! Not too bad, eh? Remember, the complete source code is available for download from the Apress web site so if you don’t want to make these changes yourself, you can download the sample code and get the completed file. However, I do recommend you build the solution yourself otherwise so you can learn how to mix C++ and C# projects in the same solution.

You use a couple of tasks in the code. You do this because the initialization of the libraries (for example, the Wait() method) should not run in the UI thread. This is a very common technique when working with libraries and other assemblies.

But wait, how does this class work to read the data from the sensor? I mentioned the code needs to read multiple bytes from the sensor and decode them. The authors of the donor class have done their homework well and have implemented the code based on the recommendations from the manufacturer’s data sheet. Take a moment while you are in the code to look around. There is a whole lot more code in there than what you’ve seen in the last few code listings!

So, how did the authors know what to do? Figure 12-3 shows an excerpt from the data sheet that outlines how to read data from the sensor.

Figure 12-3. Excerpt from BMP280 data sheet

Clearly, there is a lot going on here! What complicates the code are features in the BMP280 to provide calibration data, which is used to correct the values read. Given you must read multiple bytes and interpret them, the code is quite complex. Fortunately, all the hard work has been done for us and you can simply use the code provided. This is often the case for complex breakout boards like the BMP280 from Adafruit. If you ever have to implement your own code for such a component, be sure to read and study the data sheet. You should also consider searching the Internet for solutions. Often times you can find a solution that may not be written in your language of choice but you can either rewrite or as you’ve seen in this chapter, use the power of Visual Studio to combine C# and C++ in the same solution.

Now, let’s add the user interface code.

User Interface

The user interface code is very simple—just four labels: one for the title, and one for each of the values read (temperature, pressure, and altitude). Listing 12-6 shows the XAML code for the interface. Open the MainPage.xaml file in the Weather project and edit the file as shown. The new lines you need to add are shown in bold.

Listing 12-6. User Interface Code

...
    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <StackPanel Width="400" Height="400">            
            <TextBlock x:Name="Title" Height="60" TextWrapping="NoWrap"            
                     Text="Weather Station" FontSize="28" Foreground="Blue"            
                     Margin="10" HorizontalAlignment="Center"/>            
            <TextBlock x:Name="Temp" Height="60" TextWrapping="NoWrap"            
                     Text="Initializing..." FontSize="28" Foreground="Blue"            
                     Margin="10" HorizontalAlignment="Center"/>            
            <TextBlock x:Name="Press" Height="60" TextWrapping="NoWrap"            
                     Text="Initializing..." FontSize="28" Foreground="Blue"            
                     Margin="10" HorizontalAlignment="Center"/>            
            <TextBlock x:Name="Alt" Height="60" TextWrapping="NoWrap"            
                     Text="Initializing..." FontSize="28" Foreground="Blue"            
                     Margin="10" HorizontalAlignment="Center"/>            
        </StackPanel>            
    </Grid>
...                                                                                           

Figure 12-4 shows an example of what the user interface will look like when the application runs on the Raspberry Pi.

Figure 12-4. Example user interface

Add References

There are only two references needed—one for each project. Let’s start with the WeatherSensor project. Right-click References in the project tree in the Solution Explorer and add the Windows 10 IoT Extensions reference. You also need to add a reference in the Weather project that references the WeatherSensor project. Right-click References in the project tree in the Solution Explorer and add the WeatherSensor project, as shown in Figure 12-5. Be sure to tick the box before clicking OK.

Figure 12-5. Adding the WeatherSensor project reference

You should now see the WeatherSensor project in the Weather project references and the Windows 10 IoT extensions in the WeatherSensor project references. If you encounter strange build issues or errors, be sure to check the references.

You may be presented with a dialog during project creation or when you add references to the project. The dialog asks you to determine the minimum and required versions for the IoT extensions. You should choose the Build 10586 entries for both. Figure 12-6 shows an example of the dialog that you may see.

Figure 12-6. Target version dialog

You’re almost there! You just need to add the code to use the BMP280 class and update the user interface. Let’s do that now.

Reading the Weather Data

Now let’s add the code to read the temperature, pressure, and altitude from the BMP280 class and display it in the user interface you implemented. Since you are working with C++, you have a separate header file that you put the variables and declarations for methods (called functions in C++). Open the MainPage.xaml.h file and make the following changes. Listing 12-7 shows the entire code for the file.

Listing 12-7. The MainPage.xaml.h Header File

#pragma once

#include "MainPage.g.h"

using namespace WeatherSensor;  // Add for sensor C# project                  

namespace Weather
{
        public ref class MainPage sealed
        {
        public:
                MainPage();
        private:
                // Reference to BMP280 C# class              
                BMP280 ^bmp280 = ref new BMP280();              

                // Variable for the timer              
                Windows::UI::Xaml::DispatcherTimer ^timer_;              

                // Timer on tick method              
                void OnTick(Platform::Object ^sender, Platform::Object ^args);              
        };
}

Notice you added a namespace that references the BMP280 class (the WeatherSensor namespace), and then added a variable reference to the class. You add these to the private section by convention. You also add a variable for a timer that you will use to read and update the user interface and the method, which is called on each “tick” of the timer event.

Next, you edit the MainPage.xaml.cpp file and add the code to read the data. But first, you need to add a namespace for the timer code. In this case, you need the currency namespace.

Next, you edit the constructor code to call the Initialize() method on the BMP280 instance and then set up the timer code. You use a small update (delay) but you can increase this once you are comfortable the solution is working correctly. If you have been following along with the projects in the previous projects, this code should look familiar in a not-C#-but-similar manner.

Next, you add the code for the OnTick() method. You use this method to read the data and update the user interface. You first read each of the values and then update the corresponding label in the user interface. Listing 12-8 shows an excerpt of the file with all the code needed for the constructor and the new method.

Listing 12-8. The MainPage.xaml.cpp Source File

...
using namespace Windows::UI::Xaml::Navigation;
using namespace concurrency; // Add for timer                  

MainPage::MainPage()
{

        InitializeComponent();

        // Initialize the sensor
        bmp280->Initialize();

        // Setup timer
        timer_ = ref new DispatcherTimer();
        TimeSpan interval;
        interval.Duration = 1000 * 1000 * 10;
        timer_->Interval = interval;
        timer_->Tick += ref new EventHandler<Object ^>(this, &MainPage::OnTick);
        timer_->Start();
}

void MainPage::OnTick(Object ^sender, Object ^args)
{
        // Initialize the variables
        float temp = 0;
        float pressure = 0;
        float altitude = 0;

        // Create a constant for pressure at sea level.
        // This is based on your local sea level pressure (Unit: Hectopascal)
        // To find the sea level pressure for your area, go to:
        // weather.gov and enter your city then read the pressure from the
        // history.
        const float seaLevelPressure = 1013.25f;

        // Read samples of the data every 10 seconds
        temp = bmp280->ReadTemperature();
        pressure = bmp280->ReadPreasure();
        altitude = bmp280->ReadAltitude(seaLevelPressure);

        Temp->Text = "Temperature: " + temp + " C";
        Press->Text = "Pressure: " + pressure + " Pa";
        Alt->Text = "Altitude: " + altitude + " m";
}

You supply a constant for the sea level pressure. This value may be different for your location. Check the weather web sites for your location to get the latest calculated sea level pressure. Substitute your value in the code to get more accurate altitude calculations. That is, the altitude is the result of a calculation based on the barometric pressure and sea level pressure values. Thus, it may not be accurate but should be pretty close if you use the correct value for your area.

That’s it! The code is complete and ready for compilation. Be sure to check the preceding listings to ensure that you have all the code in the right place. Once you have entered all the code, you should now attempt to compile the solution. You can compile the projects individually, but if you do so, start with the WeatherSensor project. Once that is compiling correctly, you can compile the weather project. Or you can just build the entire solution. Correct any errors you find until the code compiles without errors or warnings.