Edi Wang

Azure Remote Controlled Light with .NET Core 3.0 on Raspberry Pi

2019-10-06T15:59:35Z

3 years ago, I wrote a blog post "Azure Remote Controlled Light with Windows 10 IoT Core", which is an experiment to sending a signal from your home and it will travel around the world then come back to your home to turn on an LED light on your Raspberry Pi. 3 years later, Windows 10 IoT Core and UWP seem not living so well. Microsoft doesn't have a new build of Windows 10 to support the latest Raspberry Pi 4 currently. I have a Pi 4, so I have no choice but to use .NET Core on Linux. Microsoft and the community are rapidly developing the .NET IoT libraries here, so it's very easy to move my old project from UWP to .NET Core 3.0 on Linux.

Before we begin, please check out "Setup .NET Core 3.0 Runtime and SDK on Raspberry Pi 4" if you haven't installed .NET Core on your Raspberry Pi.

Overview

We are going to send messages from our computer to Azure IoT Hub, and Raspberry Pi will listen to the message and turn on/off the LED.

Create Azure IoT Hub

Refer to Azure document to create an IoT Hub. Copy your connection string, it looks like this:

HostName=<Your Hub Name>.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<Your Key>

Download and install Azure Device Explorer from https://aka.ms/aziotdevexp

Copy your IoT Hub connection string and paste it into the main tab. Then hit the "Update" button.

Then go to the "Management" tab, click "Create", enter your device name for your Raspberry Pi and select "Auto Generate Keys"

After the registration, you would see the result listed in the grid view.

Physical Connection on the Pi

Connect an LED to your Raspberry Pi with:

Long led to GPIO 17
Short leg to GROUND

Create AzureLightControl Project

Create a new .NET Core 3.0 Console project. Add Microsoft.Azure.Devices.Client and System.Device.Gpio NuGet packages. Microsoft.Azure.Devices.Client talks to Azure IoT Hub, while System.Device.Gpio controls the GPIO for switching the LED. The project file looks like this:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Azure.Devices.Client" Version="1.21.1" />
    <PackageReference Include="System.Device.Gpio" Version="1.0.0" />
  </ItemGroup>

</Project>

Replace Program.cs with the following content. Replace the const string content with your own value from Azure.

using System;
using System.Device.Gpio;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.Devices.Client;
using Microsoft.Azure.Devices.Client.Exceptions;

namespace AzureLightControl
{
    class Program
    {
        private const string IotHubUri = "<Your Hub Name>.azure-devices.net";
        private const string DeviceKey = "<Your Key>";
        private const string DeviceId = "<Your Device ID>";
        private const int Pin = 17;

        private static CancellationToken _ct;

        static async Task Main(string[] args)
        {
            Console.WriteLine("------------------------------");
            Console.WriteLine(" Azure IoT Hub Light Control");
            Console.WriteLine("------------------------------");

            var cts = new CancellationTokenSource();
            _ct = cts.Token;

            Console.CancelKeyPress += (sender, eventArgs) =>
            {
                Console.WriteLine($"{DateTime.Now} > Cancelling...");
                cts.Cancel();

                eventArgs.Cancel = true;
            };
            
            try
            {
                var t = Task.Run(Run, cts.Token);
                await t;
            }
            catch (IotHubCommunicationException)
            {
                Console.WriteLine($"{DateTime.Now} > Operation has been canceled.");
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine($"{DateTime.Now} > Operation has been canceled.");
            }
            finally
            {
                cts.Dispose();
            }

            Console.ReadKey();
        }

        private static async Task Run()
        {
            using var deviceClient = DeviceClient.Create(IotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(DeviceId, DeviceKey));
            using var controller = new GpioController();
            controller.OpenPin(Pin, PinMode.Output);

            Console.WriteLine($"{DateTime.Now} > Connected to the best cloud on the planet.");
            Console.WriteLine($"Azure IoT Hub: {IotHubUri}");
            Console.WriteLine($"Device ID: {DeviceId}");

            Console.WriteLine($"{DateTime.Now} > GPIO pin enabled for use: {Pin}");

            while (!_ct.IsCancellationRequested)
            {
                Console.WriteLine($"{DateTime.Now} > Waiting new message from Azure...");
                var receivedMessage = await deviceClient.ReceiveAsync(_ct);
                if (receivedMessage == null) continue;

                var msg = Encoding.ASCII.GetString(receivedMessage.GetBytes());
                Console.WriteLine($"{DateTime.Now} > Received message: {msg}");

                switch (msg)
                {
                    case "on":
                        Console.WriteLine($"{DateTime.Now} > Turn on the light.");
                        controller.Write(Pin, PinValue.High);
                        break;
                    case "off":
                        Console.WriteLine($"{DateTime.Now} > Turn off the light.");
                        controller.Write(Pin, PinValue.Low);
                        break;
                    default:
                        Console.WriteLine($"Unknown command: {msg}");
                        break;
                }

                await deviceClient.CompleteAsync(receivedMessage, _ct);
            }
        }
    }
}

In this example, deviceClient.ReceiveAsync() method will listen for any new message from Azure IoT Hub. Process it, and then call CompleteAsync() to tell Azure a message has been processed, so it won't be processed again if the device reconnects to Azure.

Processing the message is very straight forward, read the message as string content, if it says "on", write a GPIO HIGH to pin 17, this can light up the LED. If the message content is "off", write a GPIO LOW to pin 17 to turn off the LED. The GPIO operation for controlling an LED is PinMode.Output, if you work with sensors, it is usually PinMode.Input.

Deploy and Run

Copy the source code or publish it to Raspberry Pi.

On your Raspberry Pi: Use dotnet CLI to run this project. (If you don't know how, please refer to "Setup .NET Core 3.0 Runtime and SDK on Raspberry Pi 4")

On your PC: Send message content "on" or "off" to your Raspberry Pi in Device Explorer.

You have the magic to control a light over the internet now:

Setup .NET Runtime and SDK on Raspberry Pi 4

2019-09-29T09:29:07Z

I recently bought a Raspberry Pi 4 with 4GB RAM. I've managed to run an ASP.NET Core application on this Raspberry Pi 4.

05/13/2022 Update content for .NET 6.0 LTS for ARM64. Original post is for .NET Core 3.1 ARM32.

ARM32 or ARM64?

You can't run ARM64 version of .NET Core runtime or SDK on a Raspberry Pi 4 with the official Raspbian system today. Although Raspberry Pi 4's CPU supports 64 bit, its official operating system "Raspbian" isn't 64 bit. However, Ubuntu for Raspberry Pi 4 can install ARM64 .NET 6.0 SDK. It's up to you to choose ARM32 or ARM64. The setup steps are the same.

Prepare

Required: An Internet connection for downloading .NET SDK and Runtime.

Optional: Visual Studio Code / Visual Studio on your desktop machine to create a sample project

Update your Raspbian:

sudo apt-get update
sudo apt-get upgrade

I also suggest using a monitor for your Raspberry Pi or a VNC connection, so that you can test your ASP.NET Core websites at the final step without messing up the port and network settings.

Download .NET SDK and Runtime

On your desktop machine, open https://dotnet.microsoft.com/download/dotnet-core/6.0

Find Linux distributions for ARM32/64 SDK and ASP.NET Core Runtime, click into it, you can then copy the Direct Link. These 2 links are what we use in Raspbian / Ubuntu to download the latest SDK and Runtime. For example:

.NET Core 6.0 SDK (Linux/ARM64)
- https://download.visualstudio.microsoft.com/download/pr/7c62b503-4ede-4ff2-bc38-50f250a86d89/3b5e9db04cbe0169e852cb050a0dffce/dotnet-sdk-6.0.300-linux-arm64.tar.gz
ASP.NET Core 3.1 Runtime (Linux/ARM64)
- https://download.visualstudio.microsoft.com/download/pr/8ba7087e-4513-41e5-8359-a4bcd2a3661f/e6828f0d8cf1ecc63074c9ff57685e27/aspnetcore-runtime-6.0.5-linux-arm64.tar.gz

Use wget on your Raspbian to download .NET SDK and ASP.NET Core runtime, for example, Linux ARM64:

wget https://download.visualstudio.microsoft.com/download/pr/7c62b503-4ede-4ff2-bc38-50f250a86d89/3b5e9db04cbe0169e852cb050a0dffce/dotnet-sdk-6.0.300-linux-arm64.tar.gz
wget https://download.visualstudio.microsoft.com/download/pr/8ba7087e-4513-41e5-8359-a4bcd2a3661f/e6828f0d8cf1ecc63074c9ff57685e27/aspnetcore-runtime-6.0.5-linux-arm64.tar.gz

Please always check for updated URLs for a newer version of SDK and Runtime.

Install .NET SDK and Runtime

Create a folder named for example "dotnet-arm64" and unzip them into it.

mkdir dotnet-arm64
tar zxf dotnet-sdk-6.0.300-linux-arm64.tar.gz -C $HOME/dotnet-arm64
tar zxf aspnetcore-runtime-6.0.5-linux-arm64.tar.gz -C $HOME/dotnet-arm64

So far you can only run .NET commands inside the dotnet-arm64 folder. To make "dotnet" command can be run everywhere, you have to make something like environment variables, which will link dotnet-arm64 folder to system level.

export DOTNET_ROOT=$HOME/dotnet-arm64
export PATH=$PATH:$HOME/dotnet-arm64

Now, you can run dotnet --info to have a quick test:

Create .NET Applications

Now that we have the SDK, we don't have to use another machine to develop and publish the App. We can just do it directly on our Raspberry Pi.

mkdir hello-dotnet
cd hello-dotnet
dotnet new console

After the project files are created and NuGet restore completes. You can run the project using "dotnet run" command.

You can even use nano as a basic code editor.

sudo nano Program.cs

Deploy and Run ASP.NET Core Applications

In a more real-world scenario. You just can't develop complex .NET applications without an IDE on Raspbain. We usually develop and test our App on desktop machines first and then publish it to Raspberry Pi to run it.

To run an ASP.NET Core application. You need to first publish it. For example, from Visual Studio 2022. What I have is an empty ASP.NET Core application with a little more output information in Startup.cs

await context.Response.WriteAsync($"Empower every person and every organization on the planet to achieve more{Environment.NewLine}" +
                                  $".NET Core {Environment.Version}{Environment.NewLine}" +
                                  $"Environment.OSVersion: {Environment.OSVersion}{Environment.NewLine}" +
                                  $"Environment.Is64BitOperatingSystem: {Environment.Is64BitOperatingSystem}{Environment.NewLine}" +
                                  $"Environment.Is64BitProcess: {Environment.Is64BitProcess}", Encoding.UTF8);

Publish it using Framework-Dependent (FDD) and Portable. Because we have the native runtime on Raspberry Pi. We DON'T have to build it into linux-arm RID! Portable will run just fine!

Copy the published directory to Raspberry Pi.

Now you can use "dotnet <Your DLL Name>.dll" to run your ASP.NET Core application.

"Auto Start" .NET Environment

Every time you restart your Raspberry Pi, you'll have to re-configure the DOTNET_ROOT and PATH environment variables or .NET CLI won't work. To make them auto start with the system, we can modify the ".profile".

sudo nano .profile

Add those lines at the end of this file

# set .NET SDK and Runtime path
export DOTNET_ROOT=$HOME/dotnet-arm64
export PATH=$PATH:$HOME/dotnet-arm64

Looks like this

Save the file and restart your Raspbian system. Now you can run "dotnet --info" directly without manually setting the environment variables again.

Access ASP.NET Core Website from LAN

So far your ASP.NET Core application can only be visited on Raspberry Pi itself using "localhost". It would be much more useful if we expose it to LAN. There are two ways to do that.

Host by Kestrel itself

Just give dotnet command a --urls parameter, it would listen on the domain and port you provided. I don't want to limit to any domain name, so I use * instead.

dotnet Empower.dll --urls "http://*:8080"

Now you will be able to access your Raspberry Pi via LAN.

But this hosting model has its disadvantages, for example, when you have an exception in your code, the dotnet process will end and you have to manually restart it. Let's check out a more real-world hosting model.

Host by Nginx with auto-restart capability

First, install and start Nginx:

sudo apt-get install nginx
sudo /etc/init.d/nginx start

Open Nginx config file:

sudo nano /etc/nginx/sites-available/default

Replace its content with:

server {
    listen        80 default_server;
    server_name   _;
    location / {
        proxy_pass         http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header   Upgrade $http_upgrade;
        proxy_set_header   Connection keep-alive;
        proxy_set_header   Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Proto $scheme;
    }
}

server_name is set to _; means I don't limit domain names, just accept any hostnames. proxy_pass is the default Kestrel HTTP endpoint, which runs our ASP.NET Core website.

Check and apply the config file:

sudo nginx -t
sudo nginx -s reload

Now, start your ASP.NET Core website, you will be able to access your Raspberry Pi using port 80.

dotnet Empower.dll

Now we have one last step to go, make dotnet process auto-restart in case your code accidentally blow up. To do that, we will create a systemd service.

sudo nano /etc/systemd/system/kestrel-empowerapp.service

With the following content:

[Unit]
Description=ASP.NET Core App - Empower

[Service]
WorkingDirectory=/home/pi/dotnet-playground/empower/portable-fdd
ExecStart=/home/pi/dotnet-arm64/dotnet /home/pi/dotnet-playground/empower/portable-fdd/Empower.dll
Restart=always
# Restart service after 10 seconds if the dotnet service crashes:
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=dotnet-empower
User=pi
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

Note, we can only use absolute path in systemd configuation.

sudo systemctl enable kestrel-empowerapp.service
sudo systemctl start kestrel-empowerapp.service
sudo systemctl status kestrel-empowerapp.service

Now, you have the auto start and failure restart capability for your ASP.NET Core 3.0 application running on Raspberry Pi 4. Try to reboot your Raspberry Pi, your website will auto start! It is a web server now!

For more configuration details, you can refer to Microsoft official document here.

Want Docker?

There are Microsoft official docker images supporting ARM32 on Raspberry Pi 4, if you managed to install docker on your Raspberry Pi 4, have fun :)

Reference: https://www.hanselman.com/blog/InstallingTheNETCore2xSDKOnARaspberryPiAndBlinkingAnLEDWithSystemDeviceGpio.aspx

Raspberry Pi Surveillance Camera with Linux and Azure

2016-08-11T08:47:49Z

Because Windows 10 IoT Core is not supporting Pi Camera, I can only use Linux instead. These days, I made a surveillance camera, the functionality is simple, when a person passed by the camera, it will take a picture and upload to Microsoft Azure Storage. It also got a website to remotely view the photos.

1. Hardware

A PIR Sensor, a Pi Camera, a couple of jump wires. Connect the Singal port of the PIR sensor to GPIO 04, install the camera into CSI interface on the Raspberry Pi.

For installing the camera, please refer to official document here: https://www.raspberrypi.org/documentation/raspbian/applications/camera.md

2. Working with PIR Sensor and Camera

SSH into Raspbian, create a new python file:

sudo nano pircam.py

The API for the PIR sensor is built in Raspbian system. We only need to use it directly:

from gpiozero import MotionSensor
pir = MotionSensor(4)

To test if a person is passing by the PIR sensor:

pir.wait_for_motion()

To test if no one is standing in front of the PIR Sensor:

pir.wait_for_no_motion()

The camera API is also already in place.

from picamera import PiCamera
camera = PiCamera()

To take a photo:

camera.capture(filename)

So, to take a photo when a person is passing by the PIR sensor, we could do it this way:

from gpiozero import MotionSensor
from picamera import PiCamera
from datetime import datetime

camera = PiCamera()
pir = MotionSensor(4)

while True:
    pir.wait_for_motion()
    filename = "pircam-" +  datetime.now().strftime("%Y-%m-%d_%H.%M.%S.jpg")
    camera.capture(filename)
    pir.wait_for_no_motion()

Save the python file, and execute the script:

sudo python pircam.py

If everything is good, you can cross your fingers before the PIR sensor, the camera will take a photo. You can use "ls" command to verify if the photo has been saved to disk.

3. Configuration of Azure Storage Account and How to Upload Photo

Please refer to my post 在树莓派上使用PiCamera拍照并上传到Azure

Finally the working code is:

from gpiozero import MotionSensor
from picamera import PiCamera
from datetime import datetime
from azure.storage.blob import BlockBlobService
from azure.storage.blob import ContentSettings

camera = PiCamera()
pir = MotionSensor(4)
block_blob_service = BlockBlobService(account_name='YOURACCOUNT', account_key='YOURKEY')

while True:
    pir.wait_for_motion()
    filename = "pircam-" +  datetime.now().strftime("%Y-%m-%d_%H.%M.%S.jpg")
    camera.capture(filename)
    pir.wait_for_no_motion()
    block_blob_service.create_blob_from_path(
    'YOURCONTAINER',
    filename,
    filename,
    content_settings=ContentSettings(content_type='image/jpeg'))

If nothing goes wrong, after execute the script, you will see the photos in your zure Portal:

4. Build the Website

Create a new ASP.NET MVC5 project with VS2015. Naming it like "PirCamWatcher", update all nuget packages to latest version. Install Azure Storage SDK:

PM > Install-Package WindowsAzure.Storage

Modify web.config, add the following keys into appSettings node:

    <add key="StorageConnectionString" value="DefaultEndpointsProtocol=https;AccountName=YOURACCOUNT;AccountKey=YOURKEY" />
    <add key="AzureStorageAccountContainer" value="YOURCONTAINER" />
    <add key="AuthUserName" value="YOURUSERNAME" />
    <add key="AuthPassword" value="YOURPASSWORD"/>

Please modify the values according to your own Azure envrionment.

The next thing is to make an authentication module. Because we are publishing it to the Internet, we can't allow everyone to see our photos. I choose Basic Authentication because it's the most simple way to do. To get it done in ASP.NET, we need to create an HttpModule first:

e.g. BasicAuthHttpModule

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Security.Principal;
using System.Text;
using System.Threading;
using System.Web;
using System.Web.Configuration;

namespace PirCamWatcher.IISModules
{
    public class BasicAuthHttpModule : IHttpModule
    {
        private const string Realm = "PirCam";

        public void Init(HttpApplication context)
        {
            // Register event handlers
            context.AuthenticateRequest += OnApplicationAuthenticateRequest;
            context.EndRequest += OnApplicationEndRequest;
        }

        private static void SetPrincipal(IPrincipal principal)
        {
            Thread.CurrentPrincipal = principal;
            if (HttpContext.Current != null)
            {
                HttpContext.Current.User = principal;
            }
        }

        private static bool CheckPassword(string username, string password)
        {
            var u = WebConfigurationManager.AppSettings["AuthUserName"];
            var p = WebConfigurationManager.AppSettings["AuthPassword"];
            return username == u && password == p;
        }

        private static void AuthenticateUser(string credentials)
        {
            try
            {
                var encoding = Encoding.GetEncoding("iso-8859-1");
                credentials = encoding.GetString(Convert.FromBase64String(credentials));

                int separator = credentials.IndexOf(':');
                string name = credentials.Substring(0, separator);
                string password = credentials.Substring(separator + 1);

                if (CheckPassword(name, password))
                {
                    var identity = new GenericIdentity(name);
                    SetPrincipal(new GenericPrincipal(identity, null));
                }
                else
                {
                    // Invalid username or password.
                    HttpContext.Current.Response.StatusCode = 401;
                }
            }
            catch (FormatException)
            {
                // Credentials were not formatted correctly.
                HttpContext.Current.Response.StatusCode = 401;
            }
        }

        private static void OnApplicationAuthenticateRequest(object sender, EventArgs e)
        {
            var request = HttpContext.Current.Request;
            var authHeader = request.Headers["Authorization"];
            if (authHeader != null)
            {
                var authHeaderVal = AuthenticationHeaderValue.Parse(authHeader);

                // RFC 2617 sec 1.2, "scheme" name is case-insensitive
                if (authHeaderVal.Scheme.Equals("basic",
                        StringComparison.OrdinalIgnoreCase) &&
                    authHeaderVal.Parameter != null)
                {
                    AuthenticateUser(authHeaderVal.Parameter);
                }
            }
        }

        // If the request was unauthorized, add the WWW-Authenticate header 
        // to the response.
        private static void OnApplicationEndRequest(object sender, EventArgs e)
        {
            var response = HttpContext.Current.Response;
            if (response.StatusCode == 401)
            {
                response.Headers.Add("WWW-Authenticate",
                    string.Format("Basic realm=\"{0}\"", Realm));
            }
        }

        public void Dispose()
        {
        }
    }
}

And then, configure it into Web.config:

  <system.webServer>
    <modules>
      <add name="BasicAuthHttpModule"
        type="PirCamWatcher.IISModules.BasicAuthHttpModule, PirCamWatcher"/>
    </modules>
  </system.webServer>

Open IIS, disable "Anonymous Authentication"

Now, try to access the website, it shoud ask you for a username and password

Finally, because we are deploying it to Azure. We can not operate the IIS on Azure directly, so we need a tricky way to do it:

Modify Web.Release.config, add the following code:

  <system.webServer>
    <security xdt:Transform="Insert">
      <authentication>
        <anonymousAuthentication enabled="false" />
      </authentication>
    </security>
  </system.webServer>

Open HomeController.cs, replace the code with this:

using System.Linq;
using System.Web.Configuration;
using System.Web.Mvc;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;

namespace PirCamWatcher.Controllers
{
    public class HomeController : Controller
    {
        public static CloudBlobContainer BlobContainer { get; set; }

        public HomeController()
        {
            BlobContainer = GetBlobContainer();
        }

        public ActionResult Index()
        {
            return View();
        }

        public JsonResult GetImages()
        {
            var listBlobProperties = (from item in BlobContainer.ListBlobs(null, false)
                                      where item.GetType() == typeof(CloudBlockBlob)
                                      select (CloudBlockBlob)item
                                      into blob
                                      select new Models.PirCamBlobProperties(blob.Properties.LastModified, blob.Uri))
                                     .OrderByDescending(p => p.DateModified)
                                     .ToList();

            return Json(listBlobProperties, JsonRequestBehavior.AllowGet);
        }

        private static CloudBlobContainer GetBlobContainer()
        {
            string connectionString = WebConfigurationManager.AppSettings["StorageConnectionString"];
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
            CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
            CloudBlobContainer container =
                blobClient.GetContainerReference(WebConfigurationManager.AppSettings["AzureStorageAccountContainer"]);
            return container;
        }
    }
}

Add a "PirCamBlobProperties.cs" into Models

using System;

namespace PirCamWatcher.Models
{
    public class PirCamBlobProperties
    {
        public DateTimeOffset? DateModified;

        public Uri Uri;

        public PirCamBlobProperties(DateTimeOffset? dateModified, Uri uri)
        {
            DateModified = dateModified; Uri = uri;
        }
    }
}

Open Home\Index.cshtml, replace the code with

@{
    ViewBag.Title = "Home";
}

@section scripts{
    <script>
        function showImage(uri) {
            $(".img-prev-lg").html("<img src='" + uri + "' class='img-responsive' />");
            $("#img-modal").modal();
        }

        $(function () {
            $.getJSON("Home/GetImages",
                function (data) {
                    var items = [];
                    $.each(data, function (k, v) {
                        items.push(
                            "<div class='sv-img' data-imgurl='" + v.Uri + "'>" +
                            "<img src='" + v.Uri + "' class='img-responsive' />" +
                            "<div class='sv-date'>" + new Date(parseInt(v.DateModified.substr(6))) + "</div>" +
                            "</div>");
                    });

                    $("<div />", {
                        "class": "img-container",
                        html: items.join("")
                    }).appendTo(".gallery-display");
                }).done(function () {
                    $(".sv-img").click(function () {
                        var uri = $(this).data('imgurl');
                        showImage(uri);
                    });
                });
        });
    </script>
}

<h1 class="page-header">
    Azure Home Surveillance
    <small>Raspberry Pi PIR Motion Camera</small>
</h1>

<section class="gallery-display"></section>

<div id="img-modal" class="modal fade" tabindex="-1" role="dialog">
    <div class="modal-dialog modal-lg" role="document">
        <div class="modal-content img-prev-lg">

        </div>
    </div>
</div>

Modify site.css, add code:

.sv-img {
    display: inline-block;
    width: 275px;
    margin: 0 10px 10px 0;
    border: 1px solid #CCC;
    position: relative;
    cursor: pointer;
}

.sv-date {
    color: #FFF;
    background-color: #000;
    -ms-opacity: 0.5;
    opacity: 0.5;
    position: absolute;
    bottom: 0;
    padding: 5px;
}

Publish the website to Azure, and you are good to go!

The entire project is on my github:

https://github.com/EdiWang/RaspiCameraSurveillance-Azure

Uploading PiCamera images to Azure

2016-08-08T12:15:14Z

Recently Windows 10 IoT Core Build 14393 is coming, but still without PiCamera support, WTF. So I can only choose Linux for my project. When I was using Windows, I use C# + Azure SDK to upload photos to Microsoft Azure. So how to do it on Linux?

After some research, here's how to do it.

My system is Raspbian Linux. First, we need to install Azure SDK in SSH Terminal:

sudo pip install --pre azure

Remember to execute the command as "sudo". Or you will not have permission to install it.

After installation, Python will support Azure. You will need an Azure storage account, such as mine, called "edirpi3", with a container named "webcamupload" in it.

Then, create a new py file:

sudo nano testazureblob.py

Acccessing Azure Container from python:

from azure.storage.blob import BlockBlobService
block_blob_service = BlockBlobService(account_name='edirpi3', account_key='YOURKEY')

the "account_name" and "account_key" is in your azure portal:

To upload file:

from azure.storage.blob import ContentSettings
block_blob_service.create_blob_from_path(
    'webcamupload',
    'firstblood.jpg',
    'image1.jpg',
    content_settings=ContentSettings(content_type='image/jpeg'))

To take picture:

import picamera

camera = picamera.PiCamera()
camera.capture('image1.jpg')

Integrate those two functions, we get the code for upload picture to Azure Blob:

from azure.storage.blob import BlockBlobService
from azure.storage.blob import ContentSettings
import picamera

camera = picamera.PiCamera()
camera.capture('image1.jpg')

block_blob_service = BlockBlobService(account_name='edirpi3', account_key='YOURKEY')

block_blob_service.create_blob_from_path(
    'webcamupload',
    'firstblood.jpg',
    'image1.jpg',
    content_settings=ContentSettings(content_type='image/jpeg'))

Execute python file with "sudo python":

If everything is good, you will be able to see the picture in Azure portal:

Raspberry Pi 3 and Windows 10 IoT Core Basics

2016-08-07T07:46:43Z

最近有时间，总结了一下关于树莓派3及Windows 10 IoT的基础知识。适合没有接触过硬件但有一定编程经验的读者入门。我自己刚刚买树莓派的时候花了很长时间入门，搞清楚各种概念和属于。很多网上的帖子都是分散在各个角落的，并且是英文的，有些还是过时的，有些是爆的，所以我觉得有必要总结一篇基础入门帖子。这篇文章讲的都是抛砖引玉的概念，并不包括End-To-End的Case，想要做一个完整实验的文章，请看我博客的物联网开发系列文章：http://edi.wang/category/list/iot

如果有错误和补充，欢迎在评论里指出。

一、树莓派3

树莓派是基于ARM芯片的卡片电脑，大小和一张信用卡一样。今年推出了第三代，集成了板载蓝牙和WIFI。之前的树莓派1和2都是需要用USB WIFI和蓝牙实现的，所以你要是购买树莓派，买3是最方便的，可以省去USB WIFI和蓝牙的配件。并且Windows 10 IoT的最新版已经支持了树莓派3的板载WIFI和蓝牙，使用没有问题。

物联网开发板有好几种，树莓派只是其中一种比较流行的。我也推荐使用树莓派入门，毕竟资料和周边配件都是很全的。

树莓派3相对2有如下改进：

A 1.2GHz 64-bit quad-core ARMv8 CPU

802.11n Wireless LAN

Bluetooth 4.1

Bluetooth Low Energy (BLE)

1GB RAM

4 USB ports

40 GPIO pins

Full HDMI port

Ethernet port

Combined 3.5mm audio jack and composite video

Camera interface (CSI)

Display interface (DSI)

Micro SD card slot (now push-pull rather than push-push)

VideoCore IV 3D graphics core

购买价格大概在200-300之间，不同代理商价格不一样。买回来的产品只含有一块主板和说明书，不包括SD卡。关于SD卡的选购文章后面会有讲解。SD卡的作用就相当于树莓派这台电脑的硬盘，操作系统必须烧录在SD卡里才能启动树莓派。你可以简单的理解为，你买的树莓派就是个不带硬盘的电脑主机，当然也不包括显示器。

树莓派3的接口布局如下：

其中，USB是2.0的，因为成本问题，树莓派3不能卖的太贵，用不上3.0。CSI接口是树莓派专用的摄像头接口，你也可以使用USB摄像头。但是USB摄像头的帧率只有5fps，CSI可以达到30fps。同样，Display也是树莓派专用的显示器接口。然而，这个接口所搭配的显示器需要占用GPIO端口，我们针对树莓派上所连接的硬件编程就是通过GPIO的，所以并不推荐选购这个接口的屏幕，比如官方的。树莓派有HDMI接口，推荐使用HDMI，不会占用GPIO。如果要触控，有些HDMI屏幕可以通过USB实现触控，只会占用一个USB端口。

网线接口插入的是标准网线（RJ-45），为什么我们有WIFI了还要网线呢，一是因为操作系统第一次初始化的时候并不知道你的WIFI SID和账号密码，需要用户去指定，然而物联网开发的很多场景下你并不能直接像操作电脑一样操作树莓派，通常是远程通过IP操作，所以必须用有线网络。插入网线就能获得局域网IP。另一个原因是有线网络的速度远大于WIFI，对调试程序比较有利。

二、面包板的使用

面包板是用来给你插拔电子元件的，可以随便购买，因为都是通用的，不是树莓派专用的配件。做任何电子实验都一样。一般买来的面包板长这样：

其中，最上面和最下面的两对红蓝线，一般做电源线使用，这两条线背后的孔是水平联通的，一般都是从他们引出电源的正极和负极给板子中间的洞洞眼使用。而中间的洞洞（A-E, F-J）的背后是垂直联通的，这个一定要注意，不然可能会插爆元件，造成短路。

正确的电路示意图如下：

其中，绿色覆盖的洞洞表示通电的孔，可以看到，底端是水平的，而A-E是垂直的。

面包板有好几种规格，根据不同的场合购买不同的面包板。推荐大家买一块Full size的，几块mini的，基本就够用了。

如果你不清楚面包板的排线规律，建议先用干电池和LED做联通实验，不要直接接入树莓派。如果短路，树莓派默认是会重启系统的，但电流过大也很有可能损坏树莓派。

面包板的背面是3M贴纸，用来把面包板固定在实验台上。

三、杜邦线

用来连接树莓派和电子元件的电线叫做杜邦线，长这样：

根据两端接口的不同，分为三种：

公对公

公对母

母对母

图上就是公对母的线。公的意思就是插别人的，母的意思就是被人插的，所以一看图就明白了。在平时的实验中基本这三种线都要用到，所以建议一次性购买。

四、树莓派3的GPIO端口

GPIO的意思是General Purpose Input Output （通用输入/输出），可以插人，也可以被插。我们做物联网开发使用的传感器都是通过GPIO操作的。树莓派3的GPIO布局如下：

对应主板上的布局如下：

其中，3.3V，5V表示电源输出的正级，这些端口不能通过编程操作，只是简单的供电。GND是电源负极。其他端口都可以通过编程操作。GPIO是通用端口，SPI和I2C是特殊端口，操作方式和GPIO不一样。稍后会介绍。

所以，如果要通过GPIO点亮一个LED灯泡，在不要求程序的情况下，可以直接接入3.3V输出及GND，也就相当于接了干电池：

如果要通过编程方式操作灯泡的开关，就得先了解GPIO的操作方式。GPIO模式分为输入和输出，值是高电平和低电平。比如，你的LED负极接入了GND，那么你要点亮LED，就必须给它的正极通电对吧？那么对于LED来说，正极是输入电流的，所以对应的GPIO端口应该是输出，GPIO值是高电平，这样就能点亮LED。这里我用的是通俗易懂的说法，并不严谨，如果你有电路基本知识就知道不是这样的。。。。

简单粗暴的理解，就是，GPIO High表示电源正极，GPIO Low表示电源负极。你买的传感器都有说明，哪个针脚输入高电平会产生什么操作，传感器遇到什么情况会在哪个针脚输出低或者高电平等等，这就是物联网开发的基本原理了。

五、电子元件和传感器

树莓派的外设和电脑一样，可以简单分为输入设备和输出设备。比如，LED灯泡、蜂鸣器、电机、电机驱动板就属于输出设备，那么他们对应的GPIO都应该用Output Mode。而温度湿度传感器、人体红外传感器、光线强度、声音、酒精等就属于输入设备，那么他们对应的GPIO就应该用Input Mode。

不同厂家生产的传感器定义不一样。比如蜂鸣器，通常有3个针脚，VCC代表正极，接树莓派的DC 3.3V，GND接GND，还有个Signal针脚，就接GPIO，等待输入信号。

有的蜂鸣器是低电平触发的，所以只有GPIO输出Low才会响。有些是高电平触发的，所以GPIO得输出High才会响。至于怎么用代码操作GPIO后面会讲解。

而对于输入设备，比如声音传感器，在遇到声音时候，有些厂家的输出低电平，有些输出高电平。那么在代码里，就得检测对应GPIO端口有没有输入，然后进行逻辑操作。

总之，传感器都不一样，购买和使用必须仔细阅读说明，不然可能会损坏传感器或树莓派。尤其是对电压有要求的传感器，比如HC-SR04这种，输入5V输出5V的，GPIO只能接受3.3v，就必须加电阻分压才能使用。

推荐大家购买传感器的同时，买一个常用电阻包，某宝有很多打包好的，不同阻值的电阻，几百个，才几块钱，足够用了。

六、Windows 10 IoT Core

树莓派的官方操作系统是Linux的一个分支，叫做Raspbian。作为软狗，我们怎么可以用Linux？所以必须用Windows 10来装逼。在装逼之前，首先得保证你的SD卡能承受这个逼格。据我亲测，Windows 10 IoT兼容最好的，是三星的EVO和EVO+系列SD卡：

32G，64G都是可以的，推荐大家买32G的，便宜不少也足够用。

然后你需要做这些步骤：

下载Windows 10 IOT Dashboard

https://developer.microsoft.com/en-us/windows/iot/Downloads.htm

下载Windows:

http://ms-iot.github.io/content/en-US/win10/GetStarted/SetUpYourDeviceManually.htm

如果你需要看Release Note:

https://developer.microsoft.com/en-us/windows/iot/docs/releasenotesinsiderpreview

之后，就用IOT Dashboard把Windows刷入SD卡，这个官网下载页面有非常详细的图文介绍，我就不多说了。

需要指出的是，刷完SD卡，根目录里会有个config.txt，这个是树莓派专用的，不是Windows的文件，所以得按照官网的文档来配置。文档在这里：

https://www.raspberrypi.org/documentation/configuration/config-txt.md

默认情况下不需要改任何东西，一般只有你的屏幕和Windows 10不兼容才要看着改。比如我用的微雪7寸屏，就需要改成：

max_usb_current=1
hdmi_group=2
hdmi_mode=1
hdmi_mode=87
hdmi_cvt 1024 600 60 6 0 0 0

不然Windows就会花瓶。。。

第一次启动Windows后，插入网线，然后打开电脑浏览器，输入树莓派的IP地址(可以在树莓派的屏幕上找到)：http://树莓派IP:8080

然后用默认账号登陆：Administrator, p@ssw0rd

第一次登录后记得改密码，不然局域网里任何人都能操作你的树莓派了。

七、写代码

Windows 10 IoT Core上跑的是UWP的应用程序，所以API和UWP的手机、PC开发完全一致。所以，你需要的工具依旧是VS2015+Windows 10 PC。

唯一的差别就是得添加Windows IoT Extensions for the UWP的引用，因为操作GPIO的API都在这个里面。。。

针对GPIO操作的样例代码如下：

using Windows.Devices.Gpio;
 
public void GPIO()
{
    // Get the default GPIO controller on the system
    GpioController gpio = GpioController.GetDefault();
    if (gpio == null)
        return; // GPIO not available on this system
 
    // Open GPIO 5
    using (GpioPin pin = gpio.OpenPin(5))
    {
        // Latch HIGH value first. This ensures a default value when the pin is set as output
        pin.Write(GpioPinValue.High);
     
        // Set the IO direction as output
        pin.SetDriveMode(GpioPinDriveMode.Output);
 
    } // Close pin - will revert to its power-on state 
}

这段代码就是向GPIO 05端口输出高电平的代码。如果你有个LED的正极是接在GPIO 05上的，负极接在GND上，那么这段代码是可以点亮你的LED的。

部署UWP应用到树莓派的方式一般是通过网络，VS可以自动部署到Remote Machine，或者用Windows 10 IoT的网页portal上传appx部署。这些微软物联网开发官网都有非常详细和友好的介绍，请看：

http://windowsondevices.com/

微软官方有个很好的例子库，在这里，强烈推荐大家学习参考：

https://github.com/ms-iot/samples

八、其他

树莓派壳的选购

有一点要注意：壳子的高度是否兼容散热片，如果你买了散热片，有些compact的盒子盖不上的，会爆。最好选0.5mm高度的散热片，基本能兼容市面上的任何外壳。

对于散热，大部分情况根本用不到风扇，散热片足够了。

你还可能需要的工具和配件有：

电烙铁、焊锡、焊锡膏、老虎钳、美工刀、迷你手电钻、元件收纳盒、实验台垫板、M2.5（树莓派主板的孔径是M2.5）, M3（大部分传感器的孔径是M3）铜柱及螺丝螺母、木板、有机玻璃板等等，这些都是常用的做物联网产品的东西，建议一次性购买。

How to use Windows RDP to connect Raspbian Linux

2016-08-06T08:01:36Z

Because Windows 10 IoT Core is not yet ready to replace Raspbian, in some case, we have to use Linux. The remote operation on Linux is usually done by SSH. If you want remote desktop like the one on Windows. There are two options: tightvnc or xrdp. I used to use tightvnc, it does not have any problem with daily use. But I have to install a tightvnc client on my PC. However, XRDP can be supported by Windows MSTSC. So I tried XRDP today, it's easy to setup.

First, SSH into your Raspberry Pi. Execute Command:

sudo apt-get -y install xrdp

After you are done, there is one more option, to resolve the IP by hostname using "ping" command. To make Windows CMD pingable to your Raspberry Pi, install this package:

sudo apt-get -y install samba

It will take some time to install.

After it's done, you can ping your Raspberry Pi from a Windows machine:

Now, try mstsc on Windows PC, you will be able to connect by IP or hostname.

Use your linux credential to login.

Windows 10 IoT: How to Drive an SSD1306 I2C Display

2016-08-02T06:05:05Z

I bought a 128x64 0.96 inch OLED display, like this one:

The driver chip for this screen is called SSD 1306, typically, this chip will have 2 layouts, SPI or I2C. However, the examples fo how to drive I2C with SSD 1306 is very rare, and they run on Raspbian not Windows. Luckly, with the help from a Microsoft Staff in US, we finally got the code to run the screen on Windows 10 IoT Core.

1. Physical Connection

Just like any other I2C device, connect GND to ground, VCC to DC 3.3V, SCL to clock, SDA to data.

2. Coding

The official sample gallery from Microsoft is only supporting SPI by SSD1306. The I2C version is here, but never merged to master branch, I don't know what's the hold up.

https://github.com/stefangordon/IoTCore-SSD1306-Driver

Just download and deploy to your Raspberry Pi.

This project is an UWP background app, so there will be no UI when the app is running. VS won't attach either, but the screen will work. The entrance point of the program is "StartupTask.cs"

To control the display, use "DisplayManager.cs"

The 128x64 LED can display 4 lines of text, use this method to output the text:

public void WriteLineDisplayBuf(String Line, UInt32 Col, UInt32 Row)

Row range is between 0-3, which match line 1-4 on the screen. If you want to align text to left, set "Col" to 0. Line is the content of the text, which is type of string.

To display an image, use this method:

public UInt32 WriteImageDisplayBuf(DisplayImage img, UInt32 Col, UInt32 Row)

The default example in the project is to display a "WIFI Connected" picture on line 1, "Hello" on line 2, "World" on line 3, so the code is:

        static void DrawBody()
        {
            // Row 0, and image
            display.WriteImageDisplayBuf(DisplayImages.Connected, 0, 0);

            // Row 1 - 3
            display.WriteLineDisplayBuf("Hello", 0, 1);
            display.WriteLineDisplayBuf("World", 0, 2);
        }

3. Running the Program

The result is like this

315MHz Remote Door Control by Windows 10 IoT

2016-07-21T10:00:43Z

In the past few days, I have implemented a device that mimics the remote control door of a garage with a Raspberry Pi and share it with you.

1. Remote control module

First of all, I will introduce the remote control and receiver board I use, this kind of remote control module can be bought everywhere in China, and it basically looks like this. Many roller shutter doors and garage doors use this remote control module. For radio experiments, the non-locking version is purchased, so note that it is best to purchase the antenna at the same time. The antenna is a 50 ohm single-core wire, in fact, it is a copper wire, pay attention to the frequency when buying, the radio license frequency in Chinese mainland is 315MHz, and 443MHz is also used abroad, and the remote control I bought is 315MHz. Note that the transmitting frequency and receiving frequency of the remote control should match. The remote control receiver chip is PT2272-M4, M4 means jog mode, that is, press and hold the remote control button to output a high level, release and stop the output. The ANT side of the remote control board is welded with the antenna in a vertical upward direction (relative to your device).

There are 7 interfaces on the remote control board:

PIN	Description
GND	Ground
5V	5V power input
D0	Correspondence remote control buttons
D1	Correspondence remote control buttons
D2	Correspondence remote control buttons
D3	Correspondence remote control buttons
VT	Effective signal output

Among them, D0-D3 corresponds to the four buttons A, B, C, D on the remote control. As for which is which, the module of each model is different, and you need to experiment by yourself. VT outputs high when there is a signal in D0-D3. That is, press any button on the remote control, and the VT will output.

It is important to note that the voltages of D0-D3, as well as VT outputs, are all 5V. However, the GPIO port of the Raspberry Pi receives a voltage of 3.3V, so it is necessary to divide the voltage to 3.3V with 2 resistors according to the voltage distribution law.

The law of voltage distribution refers to the fact that in a series circuit, the voltage distributed to each load is proportional to its impedance. The circuit implemented according to this principle is also called a voltage divider.

In a series circuit with only two impedances, the voltage distribution law formulas as follows:

So, I'm taking a 4.7K resistor and a 10K resistor, substituting the formula:

Vout = 5 x (10000 / (4700 + 10000))

It is equivalent to about 3.4v, which is acceptable for a Raspberry Pi.

2. Stepper motor

The stepper motor driver board I use is ULN2003, the stepper motor model is 28BYJ-48, and I have written an article on the blog before that ULN2003 drive the stepper motor, you can click here to read. So I won't talk about how to use it here.

3. Physical connection

In a nutshell, IN1-4 of the ULN2003 remote control board corresponds to GPIO ports 5, 6, 13, and 19. The VT of the remote control board corresponds to GPIO04. The 2 5V outputs on the Raspberry Pi power the remote control board and stepper motor, respectively. The connection is as follows:

The stepper motor needs to make a bracket by itself, and I used an M3 caliber drill to make holes in the ice cream stick.

4. Write code

First, let's take one of the Uln2003 driver classes from this article and introduce it into the project.

Define an enumeration type to indicate the opening and closing state of the gate, and also define a bool type to indicate whether the motor is in operation or not.

public bool IsBusy { get; set; }

private DoorStatus Status { get; set; }

enum DoorStatus
{
    Open,
    Closed
}

Define GPIO controllers, ULN2003 stepper motor drivers, and GPIO ports on the VT side of the remote controller

public GpioController Controller { get; set; }

public GpioPin PinVT { get; set; }

public Uln2003Driver Uln2003Driver { get; set; }

public CancellationTokenSource Cts { get; private set; }

Define the method of opening and closing the door:

private async Task OpenDoorAsync()
{
    Cts = new CancellationTokenSource();

    await LogMessageAsync("Opening Door...");
    await Uln2003Driver.TurnAsync(90, TurnDirection.Left, Cts.Token);
    Status = DoorStatus.Open;
    await LogMessageAsync("Door is Open.");
}

private async Task CloseDoorAsync()
{
    Cts = new CancellationTokenSource();

    await LogMessageAsync("Closing Door...");
    await Uln2003Driver.TurnAsync(90, TurnDirection.Right, Cts.Token);
    Status = DoorStatus.Closed;
    await LogMessageAsync("Door is Closed.");
}

Main logic:

Controller = GpioController.GetDefault();
if (null != Controller)
{
    TxtMessage.Text += "[OK] GPIO Controller Initialized." + Environment.NewLine;

    Uln2003Driver = new Uln2003Driver(Controller, 5, 6, 13, 19);
    TxtMessage.Text += "[OK] Uln2003Driver Initialized on 5,6,13,19." + Environment.NewLine;

    Status = DoorStatus.Closed;

    PinVT = Controller.OpenPin(4);
    PinVT.SetDriveMode(GpioPinDriveMode.Input);
    TxtMessage.Text += "[OK] VT Initialized on GPIO 04." + Environment.NewLine;
    PinVT.ValueChanged += async (sender, args) =>
    {
        if (!IsBusy && PinVT.Read() == GpioPinValue.High && Status != DoorStatus.Open)
        {
            IsBusy = true;
            await LogMessageAsync("Remote Signal Received on VT.");
            await OpenDoorAsync();
            await Task.Delay(2000);
            await CloseDoorAsync();
            IsBusy = false;
        }
    };
}

5. Operation

Press any button on the remote control and the ice cream stick will rise. It automatically lowers after 2 seconds.

Reed Controlled Light by Windows 10 IoT Core

2016-06-10T11:34:53Z

Reed switch is an electronic component to connect / disconnect the switch by magnetic field. When it touchs magnetic field, the two iron sheets inside the tube will clip together, so the switch is connected.

The application of Reed Swith：

Door light controller: When you open the door, turn the light on. When you close the door, turn off the light. This is simply install a reed switch on your door handler, and install a magnetite on the doorframe.

Of course, you can also make an alarm and install it on your door.

There are many other scenarios that uses a reed swtich. This article talks about how to turn on/off a light by the reed switch.

1. Physical Connection

Connect Reed's VCC to DC3.3, GND toGROUND, DO to GPIO 05

Connect LED positive pin to DC3.3, nagtive pin to GPIO 06

2. Coding

Define GPIO Controller, Reed switch's GPIO pin, LED's GPIO pin and LED's on/off flag.

public GpioController GpioController { get; set; }

public GpioPin ReedPin { get; set; }

public GpioPin LedPin { get; set; }

public bool IsLightOn { get; set; }

Initiate GPIO controller

GpioController = GpioController.GetDefault();
if (null != GpioController)
{

}

Rememeber to check "null" first to ensure your program doesn't blow up on non-GPIO devices.

Open the reed switch's GPIO pin:

ReedPin = GpioController.OpenPin(5);

Set it to input mode:

ReedPin.SetDriveMode(GpioPinDriveMode.Input);

Similarly, open LED pin, and set to output.

 LedPin = GpioController.OpenPin(6);
 LedPin.SetDriveMode(GpioPinDriveMode.Output);

By default, the LED is turned off, so it requires a GPIO.HIGH at first.

LedPin.Write(GpioPinValue.High);

Then, listen to the ValueChanged event on the reed's pin.

ReedPin.ValueChanged += (sender, args) =>
{

};

In this event handler, check if the reed signal is GPIO.LOW, if it is LOW, that means it's currently in a magnetic field, so turn on the light. If not, turn off the light.

if (ReedPin.Read() == GpioPinValue.Low)
{
    IsLightOn = !IsLightOn;

    LedPin.Write(IsLightOn ? GpioPinValue.Low : GpioPinValue.High);
}

Final code:

using Windows.Devices.Gpio;
using Windows.UI.Xaml.Controls;

namespace WindowsIoTReedLight
{
    public sealed partial class MainPage : Page
    {
        public GpioController GpioController { get; set; }

        public GpioPin ReedPin { get; set; }

        public GpioPin LedPin { get; set; }

        public bool IsLightOn { get; set; }

        public MainPage()
        {
            this.InitializeComponent();

            GpioController = GpioController.GetDefault();
            if (null != GpioController)
            {
                ReedPin = GpioController.OpenPin(5);
                ReedPin.SetDriveMode(GpioPinDriveMode.Input);
                ReedPin.ValueChanged += (sender, args) =>
                {
                    if (ReedPin.Read() == GpioPinValue.Low)
                    {
                        IsLightOn = !IsLightOn;

                        LedPin.Write(IsLightOn ? GpioPinValue.Low : GpioPinValue.High);
                    }
                };

                LedPin = GpioController.OpenPin(6);
                LedPin.SetDriveMode(GpioPinDriveMode.Output);
                LedPin.Write(GpioPinValue.High);
            }
        }
    }
}

3. Running

Deploy the project to raspberry pi. Take a magnetite and closing in the reed switch, you will see the light will be turned on. Move away the magnetite, the light will be turned off.

74HC595 4 Digits LED Tube with Windows 10

2016-04-29T08:15:01Z

One of the commonly used LED Tube driver chip is 74HC595, by using the Chip, you can save GPIO ports. I bought an LED Tube with 595 chip, it only needs 3 GPIO ports to display 4 digits. However, there is no existing posts about how to drive the 74HC595 LED Tube from Windows 10. So, I can only try for myself.

1. Physical Connection

VCC to DC3.3 power, GND to Ground, DIO to GPIO27 (you can change it, and change the program also). SCLK to gpio 5 (you can also change), RCLK to GPIO 06.

As shown below:

2. Coding

The shop give me a C++ code on Arduino:

/*******************************************************************************	
* Software Author:	HQ	
* Creation Date:        2015-2-10 
* Software History:	2015-3-20
* Version:              2.0 
* Sales address：       http://qifeidz.taobao.com/
********************************************************************************/

    unsigned char LED_0F[] = 
    {// 0	 1	  2	   3	4	 5	  6	   7	8	 9	  A	   b	C    d	  E    F    -
    	0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x8C,0xBF,0xC6,0xA1,0x86,0xFF,0xbf
    };
    unsigned char LED[4];	//用于LED的4位显示缓存
    int SCLK = 2;
    int RCLK = 1;
    int DIO = 0; //这里定义了那三个脚
    void setup ()
    {
      pinMode(SCLK,OUTPUT);
      pinMode(RCLK,OUTPUT);
      pinMode(DIO,OUTPUT); //让三个脚都是输出状态
    }
    void loop()
    {
        LED[0]=1;
    	LED[1]=2;
    	LED[2]=3;
    	LED[3]=4;
    	while(1)
    	{
    		LED4_Display ();
    	} 
      
    }
    
    void LED4_Display (void)
    {
    	unsigned char *led_table;          // 查表指针
    	unsigned char i;
    	//显示第1位
    	led_table = LED_0F + LED[0];
    	i = *led_table;
    	LED_OUT(i);			
    	LED_OUT(0x01);		
        digitalWrite(RCLK,LOW);
        digitalWrite(RCLK,HIGH);
    	//显示第2位
    	led_table = LED_0F + LED[1];
    	i = *led_table;
    	LED_OUT(i);		
    	LED_OUT(0x02);		
        digitalWrite(RCLK,LOW);
        digitalWrite(RCLK,HIGH);
    	//显示第3位
    	led_table = LED_0F + LED[2];
    	i = *led_table;
    	LED_OUT(i);			
    	LED_OUT(0x04);	
        digitalWrite(RCLK,LOW);
        digitalWrite(RCLK,HIGH);
    	//显示第4位
    	led_table = LED_0F + LED[3];
    	i = *led_table;
    	LED_OUT(i);			
    	LED_OUT(0x08);		
        digitalWrite(RCLK,LOW);
        digitalWrite(RCLK,HIGH);
    }
    
    void LED_OUT(unsigned char X)
    {
    	unsigned char i;
    	for(i=8;i>=1;i--)
    	{
    		if (X&0x80) 
                {
                  digitalWrite(DIO,HIGH);
                 }  
                else 
                {
                  digitalWrite(DIO,LOW);
                }
    		X<<=1;
                digitalWrite(SCLK,LOW);
                digitalWrite(SCLK,HIGH);
    	}
    }

We only need to display Numbers. So we only need 0-9 from the LED_0F array, the C# definition is this:

byte[] LEDDIGITS =
{
    // 0    1    2    3    4	5	 6	  7	   8    9
    0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90
};

GPIO Pins:

public GpioPin PinDIO { get; set; }     // Serial Digital Input
public GpioPin PinRCLK { get; set; }   // Register Clock
public GpioPin PinSCLK { get; set; }   // Serial Clock

Initiate GPIO Controller and Pins.

public LED74HC595Driver(int dioPin, int rclkPin, int sclkPin)
{
    var gpio = GpioController.GetDefault();

    // setup the pins
    PinDIO = gpio.OpenPin(dioPin);
    PinDIO.SetDriveMode(GpioPinDriveMode.Output);

    PinRCLK = gpio.OpenPin(rclkPin);
    PinRCLK.SetDriveMode(GpioPinDriveMode.Output);

    PinSCLK = gpio.OpenPin(sclkPin);
    PinSCLK.SetDriveMode(GpioPinDriveMode.Output);

    // initialize the pins to low
    PinDIO.Write(GpioPinValue.Low);
    PinRCLK.Write(GpioPinValue.Low);
    PinSCLK.Write(GpioPinValue.Low);
}

C# translation of "void LED_OUT(unsigned char X)"

// Serial-In-Parallel-Out
void WriteSIPO(byte b)
{
    for (int i = 8; i >= 1; i--)
    {
        PinDIO.Write((b & 0x80) > 0 ? GpioPinValue.High : GpioPinValue.Low);
        b <<= 1;
        PulseSCLK();
    }
}

In order to use it more handy, add 2 helper methods

// Pulse Register Clock
void PulseRCLK()
{
    PinRCLK.Write(GpioPinValue.Low);
    PinRCLK.Write(GpioPinValue.High);
}

// Pulse Serial Clock
void PulseSCLK()
{
    PinSCLK.Write(GpioPinValue.Low);
    PinSCLK.Write(GpioPinValue.High);
}

Now we can refact the logic of "void LED4_Display (void)". Create a new method, to display a single number on a particular tube.

public void DisplayChar(int index, byte b)
{
    if (index < 0 || index > 3)
    {
        throw new ArgumentOutOfRangeException(nameof(index), "index just be between 0-3.");
    }

    int i = 0x01;
    i = i << index;

    WriteSIPO(b);
    WriteSIPO((byte)i);
    PulseRCLK();
}

The index stands for different tubes from right to left. 0 is the 1st tube, 2 is the second, 3 is the third, 4 is the last. Because it is 4 digits, it can not excceed 9999, so remember to check the range. I didn't consider the nagetive numbers, so it will be 0-9999.

For example, you want to display "8" on the second tube, like _ _ 8 _

DisplayChar(1, 0x80)

the number "8" is already defined in LEDDIGITS.

In order to be easy to use, write a method, take int type number, then convert to byte to display.

public void DisplayDigits(int number)
{
    if (number < 0 || number > 9999)
    {
        throw new ArgumentOutOfRangeException(nameof(number), "number must be between 0-9999");
    }

    // 老司机写法
    var numStr = number.ToString();
    for (int i = 0; i < numStr.Length; i++)
    {
        var pos = numStr[numStr.Length - i - 1] - '0';
        DisplayChar(i, LEDDIGITS[pos]);
    }

    // 新司机写法
    //// 个位
    //var ge = number % 10;

    //// 十位
    //var shi = number / 10 % 10;

    //// 百位
    //var bai = number / 100 % 10;

    //// 千位
    //var qian = number / 1000 % 10;

    //DisplayChar(0, LEDDIGITS[ge]);
    //DisplayChar(1, LEDDIGITS[shi]);
    //DisplayChar(2, LEDDIGITS[bai]);
    //DisplayChar(3, LEDDIGITS[qian]);
}

Then is the difficult part. How the LED Tube works is, by refreshing the characters on each tube for a very fast rate, human eye can not see the refresh, it will show like there are 4 digits at the same time. So that's why there are a while(1) loop in that C++ code.

Translating to C#, in UWP, you will need a background worker so your app start page don't stuck.

public sealed partial class MainPage : Page
{
    public LED74HC595Driver Led74Hc595Driver { get; set; }

    public MainPage()
    {
        InitializeComponent();

        Led74Hc595Driver = new LED74HC595Driver(26, 6, 5);

        BackgroundWorker worker = new BackgroundWorker { WorkerSupportsCancellation = true };
        worker.DoWork += (sender, args) =>
        {
            while (true)
            {
                Led74Hc595Driver.DisplayDigits(1024);
            }
        };

        Loaded += (sender, args) =>
        {
            worker.RunWorkerAsync();
        };
    }
}

Finally, the complete code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Devices.Gpio;

namespace LEDTube74HC595
{
    public class LED74HC595Driver
    {
        byte[] LEDDIGITS =
        {
            // 0    1    2    3    4	5	 6	  7	   8    9
    	    0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90
        };

        private byte[] LEDCHARS =
        {
            // A     b     C     d     E     F     -
            0x8C, 0xBF, 0xC6, 0xA1, 0x86, 0xFF, 0xbf
        };

        public GpioPin PinDIO { get; set; }     // Serial Digital Input
        public GpioPin PinRCLK { get; set; }   // Register Clock
        public GpioPin PinSCLK { get; set; }   // Serial Clock

        public LED74HC595Driver(int dioPin, int rclkPin, int sclkPin)
        {
            var gpio = GpioController.GetDefault();

            // setup the pins
            PinDIO = gpio.OpenPin(dioPin);
            PinDIO.SetDriveMode(GpioPinDriveMode.Output);

            PinRCLK = gpio.OpenPin(rclkPin);
            PinRCLK.SetDriveMode(GpioPinDriveMode.Output);

            PinSCLK = gpio.OpenPin(sclkPin);
            PinSCLK.SetDriveMode(GpioPinDriveMode.Output);

            // initialize the pins to low
            PinDIO.Write(GpioPinValue.Low);
            PinRCLK.Write(GpioPinValue.Low);
            PinSCLK.Write(GpioPinValue.Low);
        }

        public void DisplayChar(int index, byte b)
        {
            if (index < 0 || index > 3)
            {
                throw new ArgumentOutOfRangeException(nameof(index), "index just be between 0-3.");
            }

            int i = 0x01;
            i = i << index;

            WriteSIPO(b);
            WriteSIPO((byte)i);
            PulseRCLK();
        }

        public void DisplayDigits(int number)
        {
            if (number < 0 || number > 9999)
            {
                throw new ArgumentOutOfRangeException(nameof(number), "number must be between 0-9999");
            }

            // 老司机写法
            var numStr = number.ToString();
            for (int i = 0; i < numStr.Length; i++)
            {
                var pos = numStr[numStr.Length - i - 1] - '0';
                DisplayChar(i, LEDDIGITS[pos]);
            }

            // 新司机写法
            //// 个位
            //var ge = number % 10;

            //// 十位
            //var shi = number / 10 % 10;

            //// 百位
            //var bai = number / 100 % 10;

            //// 千位
            //var qian = number / 1000 % 10;

            //DisplayChar(0, LEDDIGITS[ge]);
            //DisplayChar(1, LEDDIGITS[shi]);
            //DisplayChar(2, LEDDIGITS[bai]);
            //DisplayChar(3, LEDDIGITS[qian]);
        }

        // Serial-In-Parallel-Out
        void WriteSIPO(byte b)
        {
            for (int i = 8; i >= 1; i--)
            {
                PinDIO.Write((b & 0x80) > 0 ? GpioPinValue.High : GpioPinValue.Low);
                b <<= 1;
                PulseSCLK();
            }
        }

        // Pulse Register Clock
        void PulseRCLK()
        {
            PinRCLK.Write(GpioPinValue.Low);
            PinRCLK.Write(GpioPinValue.High);
        }

        // Pulse Serial Clock
        void PulseSCLK()
        {
            PinSCLK.Write(GpioPinValue.Low);
            PinSCLK.Write(GpioPinValue.High);
        }
    }
}

3. Running

Using stepper motor in Windows 10 IoT Core

2016-04-04T01:15:00Z

If you need to precisely control the rotation angle of the equipment, ordinary motors can't do it, usually we use stepper motors. For example, the 28BYJ-48 model is easy to buy.

The stepper motor has to be used with the driver board, and the most commonly used is the driver board ULN2003 the chip, as shown in the figure below. However, note that the driver board you buy may not look the same, but it doesn't matter, as long as the chip is written on the ULN2003, you can use it, and their interfaces are the same. For the principle of stepper motor, you can see this: https://en.wikipedia.org/wiki/Stepper_motor

After getting the driver board and stepper motor, insert the motor into the white slot of the driver board, this interface has a foolproof design, so it will not be plugged in backwards.

There's a great article in English about how Windows 10 IoT drives stepper motors:

https://www.hackster.io/erickbp/stepper-motor-and-windows-10-iot-core-d3c5d6

My example is an improvement and addition based on the article above.

1. Physical Connection

First of all, it is not recommended to connect the 5V power supply of the stepper motor driver board to the 5V output of the Raspberry Pi, the Raspberry Pi will report a low voltage prompt when it is running, if you have any other devices connected to the Raspberry Pi, it is likely to cause the machine to restart. Therefore, it is recommended that you use an external 5v power supply, the positive and negative poles can be completely independent, and the negative pole can not be connected to the GND of the Raspberry Pi, which is not the same as what is said in the English information. I don't know if it will explode, though. I didn't blow up anyway.

The external power supply I use is a waste USB mouse cable, and the output of USB is 5v, which is the most convenient.

After connecting the power supply, use 4 wires to connect IN1-IN4 to the GPIO port of Raspberry Pi, the correspondence is as follows (of course, you can change it yourself, and the program should also be modified accordingly):

Driver board port	Raspberry Pi port
IN1	GPIO 26
IN2	GPIO 13
IN3	GPIO 6
IN4	GPIO 5

2. Write Code

The original code is here: https://github.com/erickbp/IoT/blob/master/Stepper%20Motor/Stepper%20Motor/Uln2003Driver.cs

I made some improvements. Post the full code first:

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using Windows.Devices.Gpio;

namespace Uln2003StepMotor
{
    public class Uln2003Driver : IDisposable
    {
        public int IntervalMs { get; set; }

        private readonly GpioPin[] _gpioPins = new GpioPin[4];

        private readonly GpioPinValue[][] _waveDriveSequence =
        {
            new[] {GpioPinValue.High, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low},
            new[] {GpioPinValue.Low, GpioPinValue.High, GpioPinValue.Low, GpioPinValue.Low},
            new[] {GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.High, GpioPinValue.Low},
            new[] {GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.High}
        };

        private readonly GpioPinValue[][] _fullStepSequence =
        {
            new[] {GpioPinValue.High, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.High},
            new[] {GpioPinValue.High, GpioPinValue.High, GpioPinValue.Low, GpioPinValue.Low},
            new[] {GpioPinValue.Low, GpioPinValue.High, GpioPinValue.High, GpioPinValue.Low},
            new[] {GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.High, GpioPinValue.High }

        };

        private readonly GpioPinValue[][] _halfStepSequence =
        {
            new[] {GpioPinValue.High, GpioPinValue.High, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.High},
            new[] {GpioPinValue.Low, GpioPinValue.High, GpioPinValue.High, GpioPinValue.High, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low},
            new[] {GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.High, GpioPinValue.High, GpioPinValue.High, GpioPinValue.Low, GpioPinValue.Low},
            new[] {GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.Low, GpioPinValue.High, GpioPinValue.High, GpioPinValue.High }
        };

        public Uln2003Driver(GpioController gpioController,
            int wireIn1, int wireIn2, int wireIn3, int wireIn4,
            GpioSharingMode sharingMode = GpioSharingMode.Exclusive, int intervalMs = 5)
        {
            var gpio = gpioController ?? GpioController.GetDefault();

            _gpioPins[0] = gpio.OpenPin(wireIn1, sharingMode);
            _gpioPins[1] = gpio.OpenPin(wireIn2, sharingMode);
            _gpioPins[2] = gpio.OpenPin(wireIn3, sharingMode);
            _gpioPins[3] = gpio.OpenPin(wireIn4, sharingMode);

            foreach (var gpioPin in _gpioPins)
            {
                gpioPin.Write(GpioPinValue.Low);
                gpioPin.SetDriveMode(GpioPinDriveMode.Output);
            }

            IntervalMs = intervalMs;
        }

        public async Task TurnAsync(TurnDirection direction, CancellationToken ct,
            DrivingMethod drivingMethod = DrivingMethod.FullStep)
        {
            bool stop = false;
            GpioPinValue[][] methodSequence;
            switch (drivingMethod)
            {
                case DrivingMethod.WaveDrive:
                    methodSequence = _waveDriveSequence;
                    break;
                case DrivingMethod.FullStep:
                    methodSequence = _fullStepSequence;
                    break;
                case DrivingMethod.HalfStep:
                    methodSequence = _halfStepSequence;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(drivingMethod), drivingMethod, null);
            }
            while (!stop)
            {
                for (var j = 0; j < methodSequence[0].Length; j++)
                {
                    for (var i = 0; i < 4; i++)
                    {
                        _gpioPins[i].Write(methodSequence[direction == TurnDirection.Right ? i : 3 - i][j]);
                    }

                    // don't pass cancellation token, will blow up.
                    await Task.Delay(IntervalMs);

                    if (ct.IsCancellationRequested)
                    {
                        Debug.WriteLine("Cancel Requested, stop now.");
                        stop = true;
                        break;
                    }
                }
            }

            Stop();
        }

        public async Task TurnAsync(int degree, TurnDirection direction, CancellationToken ct,
            DrivingMethod drivingMethod = DrivingMethod.FullStep)
        {
            var steps = 0;
            GpioPinValue[][] methodSequence;
            switch (drivingMethod)
            {
                case DrivingMethod.WaveDrive:
                    methodSequence = _waveDriveSequence;
                    steps = (int)Math.Ceiling(degree / 0.1767478397486253);
                    break;
                case DrivingMethod.FullStep:
                    methodSequence = _fullStepSequence;
                    steps = (int)Math.Ceiling(degree / 0.1767478397486253);
                    break;
                case DrivingMethod.HalfStep:
                    methodSequence = _halfStepSequence;
                    steps = (int)Math.Ceiling(degree / 0.0883739198743126);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(drivingMethod), drivingMethod, null);
            }
            var counter = 0;
            while (counter < steps)
            {
                for (var j = 0; j < methodSequence[0].Length; j++)
                {
                    for (var i = 0; i < 4; i++)
                    {
                        _gpioPins[i].Write(methodSequence[direction == TurnDirection.Right ? i : 3 - i][j]);
                    }

                    // don't pass cancellation token, will blow up.
                    await Task.Delay(IntervalMs);

                    if (ct.IsCancellationRequested)
                    {
                        Debug.WriteLine("Cancel Requested, stop now.");
                        counter = steps;
                    }
                    else
                    {
                        counter++;
                    }
                    
                    if (counter == steps)
                    {
                        break;
                    }
                }
            }

            Stop();
        }

        public void Stop()
        {
            foreach (var gpioPin in _gpioPins)
            {
                gpioPin.Write(GpioPinValue.Low);
            }
        }

        public void Dispose()
        {
            foreach (var gpioPin in _gpioPins)
            {
                gpioPin.Write(GpioPinValue.Low);
                gpioPin.Dispose();
            }
        }
    }

    public enum DrivingMethod
    {
        WaveDrive,
        FullStep,
        HalfStep
    }

    public enum TurnDirection
    {
        Left,
        Right
    }
}

The improvements are:

1. CancellationToken is added to the TurnAsync method, which can be force stop the rotation.

public async Task TurnAsync(int degree, TurnDirection direction, CancellationToken ct,
    DrivingMethod drivingMethod = DrivingMethod.FullStep)

// don't pass cancellation token, will blow up.
await Task.Delay(IntervalMs);

if (ct.IsCancellationRequested)
{
    Debug.WriteLine("Cancel Requested, stop now.");
    counter = steps;
}
else
{
    counter++;
}

2. TurnAsync adds a reload for rotating in one direction without specifying an angle. Then stop with a CancellationToken.

public async Task TurnAsync(TurnDirection direction, CancellationToken ct,
    DrivingMethod drivingMethod = DrivingMethod.FullStep)

Usage

XAML

<Button x:Name="BtnLeftForever" Content="Trun Left Forever" Click="BtnLeftForever_OnClick" />

<Button x:Name="BtnLeft90" Content="Turn Left 90" Click="BtnLeft90_OnClick" Margin="0,10,0,0" />
<Button x:Name="BtnRight90" Content="Turn Right 90" Margin="0,10,0,0" Click="BtnRight90_OnClick" />
<Button x:Name="BtnStop" Content="Stop" Margin="0,10,0,0" Click="BtnStop_OnClick"/>

<TextBox Text="10" Header="Degree" x:Name="TxtDegree" />
<Button x:Name="TurnDegree" Click="TurnDegree_OnClick" Content="Trun Left" />

Backend

public sealed partial class MainPage : Page
{
    public CancellationTokenSource Cts { get; private set; }

    public Uln2003Driver Uln2003Driver { get; set; }

    public MainPage()
    {
        this.InitializeComponent();
        var controller = GpioController.GetDefault();
        Uln2003Driver = new Uln2003Driver(controller, 26, 13, 6, 5);
    }

    private async Task TurnMotor(int degree, TurnDirection direction)
    {
        Cts = new CancellationTokenSource();
        await Uln2003Driver.TurnAsync(degree, direction, Cts.Token);
    }

    private async void BtnLeft90_OnClick(object sender, RoutedEventArgs e)
    {
        await TurnMotor(90, TurnDirection.Left);
    }

    private async void BtnRight90_OnClick(object sender, RoutedEventArgs e)
    {
        await TurnMotor(90, TurnDirection.Right);
    }

    private async void TurnDegree_OnClick(object sender, RoutedEventArgs e)
    {
        await TurnMotor(int.Parse(TxtDegree.Text), TurnDirection.Left);
    }

    private void BtnStop_OnClick(object sender, RoutedEventArgs e)
    {
        Cts.Cancel();
    }

    private async void BtnLeftForever_OnClick(object sender, RoutedEventArgs e)
    {
        Cts = new CancellationTokenSource();
        await Uln2003Driver.TurnAsync(TurnDirection.Left, Cts.Token);
    }
}

3. Run

Sound Controlled Light by Windows 10 IoT Core

2016-04-03T04:05:09Z

In many buildings, there are sound controlled light in use. When you clap your hands, the light turns on. Now, with Raspberry Pi 3 and Windows 10 IoT, we can make a sound controlled light ourselves.

The sound sensor I use is FC-04. As other sensors, the first step is calibration.

1. Calibration for FC-04 Sound Sensor

In quiet environment. Connect VCC to DC 3.3V，GND to Ground. At that time, the power LED on the FC-04 will turn on.

If the switch LED is also on, that means the sensitivity of the sensor is too high, that will need calibration.

Turns the blue potentiometer on the FC04, and make some sound, until the moment that the switch LED is off in quiet environment and on when you make sound.

2. Connecting Raspberry Pi

This sensro has 2 output pins. DO and AO. However, if you bought the FC-04 with only DO, that will also do, we are not using AO at this project.

Connect DO to GPIO 06.

Connect an LED, short leg to GROUND, long leg to GPIO 05.

3. Coding

First, we have 2 devices on GPIO pins, they are FC-04 and an LED. So, we need two properties for them to represent their GPIO pins.

In MainPage.xaml.cs add these 2 lines of code:

public GpioPin LedPin { get; set; }

public GpioPin SoundPin { get; set; }

We also need a flag to store the on/off status of the LED:

public bool IsLightOn { get; set; }

public MainPage()
{
    this.InitializeComponent();
    Loaded += OnLoaded;
}

Initiate GPIO controller:

private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
    var controller = GpioController.GetDefault();
    if (null != controller)
    {

    }
}

GPIO.High will light up the LED, so when first run, we need to set it to off.

private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
    var controller = GpioController.GetDefault();
    if (null != controller)
    {
        LedPin = controller.OpenPin(5);
        LedPin.SetDriveMode(GpioPinDriveMode.Output);
        LedPin.Write(GpioPinValue.Low); // set light to off at start up
    }
}

The GPIO 06 for FC-04 is input pin, so code is:

SoundPin = controller.OpenPin(6);
SoundPin.SetDriveMode(GpioPinDriveMode.Input);

So how do we know there's a signal coming from GPIO 06? There are two ways to do it, one is by event:

//
// Summary:
//     Occurs when the value of the general-purpose I/O (GPIO) pin changes, either because
//     of an external stimulus when the pin is configured as an input, or when a value
//     is written to the pin when the pin in configured as an output.
public event TypedEventHandler<GpioPin, GpioPinValueChangedEventArgs> ValueChanged;

Another is to use a DispatcherTimer. I will use the "event" to do the project. Because Timer can not see the signal in real time. If you set interval too large, the light will become stupid. Only continuous sound will make it on and off. If interval is too small, then your light will go on and off in a very short time, it is useless.

SoundPin.ValueChanged += (pin, args) =>
{
    var pinValue = SoundPin.Read();
    if (pinValue == GpioPinValue.Low)
    {
        Debug.WriteLine("Sound Detected!");
        LedPin.Write(IsLightOn ? GpioPinValue.Low : GpioPinValue.High);
        IsLightOn = !IsLightOn;
    }
};

Here is a trick, do not use the args.Edge in the args parameter. It's not same as Read() method. The correct real-time way is to use ValueChanged event with Read()

using System.Diagnostics;
using Windows.Devices.Gpio;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace SoundLight
{
    public sealed partial class MainPage : Page
    {
        public GpioPin LedPin { get; set; }

        public GpioPin SoundPin { get; set; }

        public bool IsLightOn { get; set; }

        public MainPage()
        {
            this.InitializeComponent();
            Loaded += OnLoaded;
        }

        private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
        {
            var controller = GpioController.GetDefault();
            if (null != controller)
            {
                LedPin = controller.OpenPin(5);
                LedPin.SetDriveMode(GpioPinDriveMode.Output);
                LedPin.Write(GpioPinValue.Low); // set light to off at start up

                SoundPin = controller.OpenPin(6);
                SoundPin.SetDriveMode(GpioPinDriveMode.Input);

                SoundPin.ValueChanged += (pin, args) =>
                {
                    var pinValue = SoundPin.Read();
                    if (pinValue == GpioPinValue.Low)
                    {
                        Debug.WriteLine("Sound Detected!");
                        LedPin.Write(IsLightOn ? GpioPinValue.Low : GpioPinValue.High);
                        IsLightOn = !IsLightOn;
                    }
                };
            }
        }
    }
}

4. Running

Deploy and run the program. Clap your hand, the light turns on. Clap again, the light turns off.

When Clapping your hand, the indicator light on the FC-04 will also lights on.

Windows 10 IoT: Detect Range with HC-04 Ultrasonic Sensor on Raspberry Pi 3

2016-04-02T10:31:43Z

HC-04是树莓派上用的比较广泛的超声波传感器，可以用来测量设备和物体之间的距离。可惜网上的资料很少有针对Windows 10的，几乎都是Python和C在Linux上的例子。

hackster.io上有一篇用HC-04做雷达的例子，但是设计的部件太多了，对单纯学习HC-04传感器的使用来说这个例子比较复杂。搜了一圈，英文资料最好的是这篇：http://www.guruumeditation.net/en/digital-io-with-windows-10-iot-raspberry-pi-2-and-the-ultrasonic-ranging-module-hc-sr04/ 国内中文资料介绍Windows 10上HC-04传感器的文章似乎还没有，所以就简单总结一下步骤。

一、物理连接

对于没有多少物理和电子知识基础的人（比如我）来说，第一步连线是比较难的。很多文章都一笔带过说“这很简单，没啥好说的”，尼玛。。。

其实要解决的问题是这样的：HC-04需要接入5V电源才能工作，它的响应输出是ECHO，这个要接到树莓派的GPIO端口上使用，但是ECHO的输出是5V，GPIO只能接受3.3V左右的输入，5V会烧掉树莓派，所以必须加电阻来爆一下，至于怎么加，我总结了一个最直观的示意图，如下：

简单来说，你需要2个电阻，一个4.7K欧，一个10K欧。为什么要这样呢，是因为根据电压分配定律，如上图所示，4.7K和10K电阻的组合可以得到3.4V的输出。这对GPIO来说是可以接受的。如果你有别的值的电阻可以让输出正好3.3V也是可以的。我在淘宝买的常用电阻包没有办法配出正好3.3V，所以只能用4.7K和10K的组合。（上图的4.3K R1标错了）

然后，传感器和树莓派的连接也可以看上面这张图来连。VCC接树莓派的5V输出，TRIG接GPIO 23，ECHO通过一个4.3K电阻之后接GPIO 24，GND接Ground。

二、代码

爆代码就可以用一个现成的类，这是国外的 http://www.guruumeditation.net/en/digital-io-with-windows-10-iot-raspberry-pi-2-and-the-ultrasonic-ranging-module-hc-sr04/ 这篇文章里抄过来的。（稍微改进过）

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Windows.Devices.Gpio;

namespace HC04
{
    public class HC04UltrasonicDistanceSensor
    {
        private GpioPin Pin_Trig, Pin_Echo;
        public double? Distance { get; }

        /// <summary>
        /// Available Gpio Pins. Refer: https://ms-iot.github.io/content/en-US/win10/samples/PinMappingsRPi2.htm
        /// </summary>
        public enum AvailableGpioPin : int
        {
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 29
            /// </summary>
            GpioPin_5 = 5,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 31
            /// </summary>
            GpioPin_6 = 6,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 32
            /// </summary>
            GpioPin_12 = 12,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 33
            /// </summary>
            GpioPin_13 = 13,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 36
            /// </summary>
            GpioPin_16 = 16,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 12
            /// </summary>
            GpioPin_18 = 18,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 15
            /// </summary>
            GpioPin_22 = 22,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 16
            /// </summary>
            GpioPin_23 = 23,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 18
            /// </summary>
            GpioPin_24 = 24,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 22
            /// </summary>
            GpioPin_25 = 25,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 37
            /// </summary>
            GpioPin_26 = 26,
            /// <summary>
            /// Raspberry Pi 2 - Header Pin Number : 13
            /// </summary>
            GpioPin_27 = 27
        }

        public HC04UltrasonicDistanceSensor(AvailableGpioPin trigPin, AvailableGpioPin echoPin)
        {
            var gpio = GpioController.GetDefault();

            Pin_Trig = gpio.OpenPin((int)trigPin);
            Pin_Trig.SetDriveMode(GpioPinDriveMode.Output);
            Pin_Trig.Write(GpioPinValue.Low);

            Pin_Echo = gpio.OpenPin((int)echoPin);
            Pin_Echo.SetDriveMode(GpioPinDriveMode.Input);
        }

        public double GetDistance()
        {
            var mre = new ManualResetEventSlim(false);

            //Send a 10µs pulse to start the measurement
            Pin_Trig.Write(GpioPinValue.High);
            mre.Wait(TimeSpan.FromMilliseconds(0.01));
            Pin_Trig.Write(GpioPinValue.Low);

            var time = PulseIn(Pin_Echo, GpioPinValue.High, 500);

            // multiply by speed of sound in milliseconds (34000) divided by 2 (cause pulse make rountrip)
            var distance = time * 17000;
            return distance;
        }

        private double PulseIn(GpioPin pin, GpioPinValue value, ushort timeout)
        {
            var sw = new Stopwatch();
            var swTimeout = new Stopwatch();

            swTimeout.Start();

            // Wait for pulse
            while (pin.Read() != value)
            {
                if (swTimeout.ElapsedMilliseconds > timeout)
                    return 3.5;
            }
            sw.Start();

            // Wait for pulse end
            while (pin.Read() == value)
            {
                if (swTimeout.ElapsedMilliseconds > timeout)
                    return 3.4;
            }
            sw.Stop();

            return sw.Elapsed.TotalSeconds;
        }
    }
}

使用方法如下：

public sealed partial class MainPage : Page
{
    public HC04UltrasonicDistanceSensor Hc04UltrasonicDistanceSensor { get; set; }
    private DispatcherTimer _timer;

    public MainPage()
    {
        this.InitializeComponent();
        Hc04UltrasonicDistanceSensor = new HC04UltrasonicDistanceSensor(
            HC04UltrasonicDistanceSensor.AvailableGpioPin.GpioPin_23, 
            HC04UltrasonicDistanceSensor.AvailableGpioPin.GpioPin_24);
    }

    protected override void OnNavigatedTo(NavigationEventArgs e)
    {
        base.OnNavigatedTo(e);

        _timer = new DispatcherTimer();

        _timer.Tick += (sender, o) =>
        {
            var distance = Hc04UltrasonicDistanceSensor.GetDistance();
            var s = $"Distance : {distance} cm";
            TxtDistance.Text = s;
            Debug.WriteLine(s);
        };

        _timer.Interval = TimeSpan.FromSeconds(1);

        _timer.Start();
    }
}

简单解释一下：

MainPage里的timer是用来定时每一秒取一次HC-04传感器返回的距离的，这个值可以自己改。这个距离是public double GetDistance()这个方法计算的。计算方法见代码注释。

三、运行

Windows 10 IoT Development: Moisture Sensor for Raspberry Pi 3

2016-03-28T11:38:14Z

I bought a moisture sensor like this recently.

After some research, there seem no articles to indicate how to use it in Windows 10. So I figured out myself.

This sensor has 4 Pins, which are:

PIN	Usage
AO	Analog Out
DO	Digital Out
GND	Ground
VCC	Power

So, let's connect VCC to DC3.3v on RPi, I use PIN 01. Connect GND to any ground header, which I use PIN 09. DO to any free GPIO header, I use 21. A complete reference of the Raspberry Pi 3 GPIO Headers is shown in the below picture.

The completed wire connection is this:

After power on the Raspberry Pi, we should see the power LED turns on:

Adjust the blue knob to calibrate the sensor not to be triggered (DO LED is not on) in dry air.

Use a cup of water to test if DO-LED can be triggered. If it is on as soon as the sensor touches water, then calibration is done, we can go on to write code.

The sensor will output GPIO High in dry air, and GPIO Low in water. Based on this fact, my code will be:

public GpioPin MoistureSensorOutputPin { get; set; }

public DispatcherTimer DispatcherTimer { get; set; }

public MainPage()
{
    this.InitializeComponent();
    Loaded += OnLoaded;
}

private async void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
    var ctl = await GpioController.GetDefaultAsync();
    MoistureSensorOutputPin = ctl?.OpenPin(21);
    if (MoistureSensorOutputPin != null)
    {
        MoistureSensorOutputPin.SetDriveMode(GpioPinDriveMode.Input);
        DispatcherTimer = new DispatcherTimer()
        {
            Interval = TimeSpan.FromSeconds(1)
        };
        DispatcherTimer.Tick += (O_O, n_n) =&gt;
        {
            var pinValue = MoistureSensorOutputPin.Read();
            if (pinValue == GpioPinValue.High)
            {
                Debug.WriteLine("Dry");
            }
            else
            {
                Debug.WriteLine("Water Detected!");
            }
        };
        DispatcherTimer.Start();
    }
}

Please pay attention not to use this event handler:

public event TypedEventHandler<GpioPin, GpioPinValueChangedEventArgs> ValueChanged;

Because this will output the result multiple times like this:

GY-30 (BH1750FVI) Light Sensor with Windows 10 IoT

2016-03-26T10:31:27Z

I purchased a GY-30 light sensor recently, this model is also known as "BH1550FVI". There seems no sample for this sensor on Windows 10 yet, so I tried to make one.

The light sensor looks like this:

My board is a Raspberry Pi 3, the GPIO layout is shown in this table:

Because GY-30 is an I2C device, so we can not use GPIO to drive it directly, we must use the I2C ports. In addition, because of it's an I2C device, it does not support hot plug. We should power off the Raspberry Pi, connect the sensor and then power on the Raspberry Pi, so that the system can identify the sensor.

The physical connections are:

VCC - PIN01 - 3.3V

ADO - [NONE] - Not using

SDA - PIN 03- SDA1 I2C

SCL - PIN 05 - SCL1 I2C

GND - PIN 06 - Ground

And then we could start coding. The official sample of I2C operations on Windows 10 IoT website is this:

I2C
        Pin 3 - I2C1 SDA
        Pin 5 - I2C1 SCL

using Windows.Devices.Enumeration;
using Windows.Devices.I2c;
 
public async void I2C()
{
    // Get a selector string for bus "I2C1"
    string aqs = I2cDevice.GetDeviceSelector("I2C1");
     
    // Find the I2C bus controller with our selector string
    var dis = await DeviceInformation.FindAllAsync(aqs);
    if (dis.Count == 0)
        return; // bus not found
     
    // 0x40 is the I2C device address
    var settings = new I2cConnectionSettings(0x40);
     
    // Create an I2cDevice with our selected bus controller and I2C settings
    using (I2cDevice device = await I2cDevice.FromIdAsync(dis[0].Id, settings))
    {
        byte[] writeBuf = { 0x01, 0x02, 0x03, 0x04 };
        device.Write(writeBuf);
    }
}

There's one thing interesting in the code, that is:

    // 0x40 is the I2C device address
    var settings = new I2cConnectionSettings(0x40);

So how do we get this address of "0x40"? I did some research and found every I2C devices are using different addresses. Generally, you will find it in their product manual. If you can not find it, you can use this method in Raspbian system:

http://www.raspberrypi-spy.co.uk/2014/11/enabling-the-i2c-interface-on-the-raspberry-pi/

My GY-30 sensor's I2C address is 0x23, if I am right, every GY-30 sensor that connecting using DC3.3v power will have the address of 0x23.

My complete code for the GY30LightSensor (This code is referring the Ardunio version here):

using System;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.I2c;

namespace GY30LightSensor
{
    public class GY30LightSensorEventArgs : EventArgs
    {
        public int? Lux { get; set; }

        public GY30LightSensorEventArgs(int? lux)
        {
            Lux = lux;
        }
    }

    public class GY30LightSensor
    {
        public int Bh1750Address => 0x23;

        public I2cDevice I2CLightSensor { get; private set; }

        private Timer PeriodicTimer { get; set; }

        public int TimerIntervalMs { get; set; }

        public event ReadingEventHandler Reading;

        public delegate void ReadingEventHandler(object sender, GY30LightSensorEventArgs e);

        private void OnReading(int lux)
        {
            Reading?.Invoke(lux, new GY30LightSensorEventArgs(lux));
        }

        public GY30LightSensor(int timerIntervalMs = 100)
        {
            TimerIntervalMs = timerIntervalMs;
        }

        public async Task InitLightSensorAsync()
        {
            string aqs = I2cDevice.GetDeviceSelector();
            /* Get a selector string that will return all I2C controllers on the system */
            var dis = await DeviceInformation.FindAllAsync(aqs);
            /* Find the I2C bus controller device with our selector string           */
            if (dis.Count == 0)
            {
                throw new FileNotFoundException("No I2C controllers were found on the system");
            }

            var settings = new I2cConnectionSettings(Bh1750Address)
            {
                BusSpeed = I2cBusSpeed.FastMode
            };

            I2CLightSensor = await I2cDevice.FromIdAsync(dis[0].Id, settings);
            /* Create an I2cDevice with our selected bus controller and I2C settings */
            if (I2CLightSensor == null)
            {
                throw new UnauthorizedAccessException(string.Format("Slave address {0} on I2C Controller {1} is currently in use by " +
                                 "another application. Please ensure that no other applications are using I2C.", settings.SlaveAddress, dis[0].Id));
            }

            /* Write the register settings */
            try
            {
                I2CLightSensor.Write(new byte[] { 0x10 }); // 1 [lux] aufloesung
            }
            /* If the write fails display the error and stop running */
            catch (Exception ex)
            {
                Debug.WriteLine("Failed to communicate with device: " + ex.Message);
                throw;
            }

            PeriodicTimer = new Timer(this.TimerCallback, null, 0, TimerIntervalMs);
        }

        private void TimerCallback(object state)
        {
            var lux = ReadI2CLux();
            OnReading(lux);
        }

        private int ReadI2CLux()
        {
            byte[] regAddrBuf = new byte[] { 0x23 };
            byte[] readBuf = new byte[2];
            I2CLightSensor.WriteRead(regAddrBuf, readBuf);

            // is this calculation correct?
            var valf = ((readBuf[0] << 8) | readBuf[1]) / 1.2; 

            return (int)valf;
        }
    }
}

Here is how to use it:

public GY30LightSensor Gy30LightSensor { get; set; }

public MainPage()
{
    this.InitializeComponent();
    Gy30LightSensor = new GY30LightSensor();

    Loaded += OnLoaded;
}

private async void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
    await Gy30LightSensor.InitLightSensorAsync();
    Gy30LightSensor.Reading += (o, args) =>
    {
        var task = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            TxtLux.Text = args.Lux + " lx";
        });
    };
}

Now, if you have some light shining on the sensor, you will get Lx value.

P.S. I have not verified if the calculation of the Lx is correct:

var valf = ((readBuf[0] << 8) | readBuf[1]) / 1.2;

Windows 10 IoT开发：UWP应用调用关机和重启命令

2016-03-24T07:19:58Z

UWP通常是没有让设备关机和重启的权限的。但是在Windows 10 IoT Core中是有办法实现的。安装Windows 10 Iot Core之后默认启动的那个欢迎页面右上角是有关机和重启按钮的。其实就是个UWP，它的源代码在：https://github.com/ms-iot/samples/tree/develop/IoTCoreDefaultApp

分析源代码可以发现，关机和重启是通过ShutDownManager这个class实现的。

#region Assembly Windows.System.SystemManagementContract, Version=2.0.0.0, Culture=neutral, PublicKeyToken=null, ContentType=WindowsRuntime
// C:\Program Files (x86)\Windows Kits\10\References\Windows.System.SystemManagementContract\2.0.0.0\Windows.System.SystemManagementContract.winmd
#endregion

using System;
using Windows.Foundation.Metadata;

namespace Windows.System
{
    [ContractVersion(typeof(SystemManagementContract), 65536)]
    [Static(typeof(IShutdownManagerStatics), 65536, "Windows.System.SystemManagementContract")]
    [Threading(ThreadingModel.Both)]
    public static class ShutdownManager
    {
        public static void BeginShutdown(ShutdownKind shutdownKind, TimeSpan timeout);
        public static void CancelShutdown();
    }
}

其中ShutdownKind的枚举类型定义如下：

#region Assembly Windows.System.SystemManagementContract, Version=2.0.0.0, Culture=neutral, PublicKeyToken=null, ContentType=WindowsRuntime
// C:\Program Files (x86)\Windows Kits\10\References\Windows.System.SystemManagementContract\2.0.0.0\Windows.System.SystemManagementContract.winmd
#endregion

using Windows.Foundation.Metadata;

namespace Windows.System
{
    [ContractVersion(typeof(SystemManagementContract), 65536)]
    public enum ShutdownKind
    {
        Shutdown = 0,
        Restart = 1
    }
}

Shutdown就是关机，Restart就是重启。

然而，如果我们要在自己的IoT应用里面调用，会碰到个巨坑。首先，代码是这样的：

private void ShutdownHelper(ShutdownKind kind)
{
    ShutdownManager.BeginShutdown(kind, TimeSpan.FromSeconds(0.5));
}

private void BtnRestart_OnClick(object sender, RoutedEventArgs e)
{
    ShutdownHelper(ShutdownKind.Restart);
}

private void BtnShutdown_OnClick(object sender, RoutedEventArgs e)
{
    ShutdownHelper(ShutdownKind.Shutdown);
}

运行就会爆炸！

抛出异常：没有权限

通常在UWP里，调用没有权限的API会爆炸的解决办法是在应用的manifest文件里勾选对应的权限。然而这个关机和重启，在VS的界面里是没有选项的。我们需要用XML编辑器打开

Package.appxmanifest，然后手工加权限：

在Package节点的属性里加个命名空间

xmlns:iot="http://schemas.microsoft.com/appx/manifest/iot/windows10"

然后再Capabilities节点里加这个：

<iot:Capability Name="systemManagement" />

最后看起来就像是这样：

<?xml version="1.0" encoding="utf-8"?>
<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" 
         xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest" 
         xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" 
         xmlns:iot="http://schemas.microsoft.com/appx/manifest/iot/windows10"
         IgnorableNamespaces="uap mp">
	...
  <Capabilities>
	...
    <iot:Capability Name="systemManagement" />
	...
  </Capabilities>
</Package>

现在再运行就OK了……

Edi Wang

Azure Remote Controlled Light with .NET Core 3.0 on Raspberry Pi

Overview

Create Azure IoT Hub

Physical Connection on the Pi

Create AzureLightControl Project

Deploy and Run

Setup .NET Runtime and SDK on Raspberry Pi 4

ARM32 or ARM64?

Prepare

Download .NET SDK and Runtime

Install .NET SDK and Runtime

Create .NET Applications

Deploy and Run ASP.NET Core Applications

"Auto Start" .NET Environment

Access ASP.NET Core Website from LAN

Host by Kestrel itself

Host by Nginx with auto-restart capability

Want Docker?

Raspberry Pi Surveillance Camera with Linux and Azure

1. Hardware

2. Working with PIR Sensor and Camera

3. Configuration of Azure Storage Account and How to Upload Photo

4. Build the Website

Uploading PiCamera images to Azure

Raspberry Pi 3 and Windows 10 IoT Core Basics

一、树莓派3

二、面包板的使用

三、杜邦线

四、 树莓派3的GPIO端口

五、电子元件和传感器

六、Windows 10 IoT Core

七、写代码

八、其他

How to use Windows RDP to connect Raspbian Linux

Windows 10 IoT: How to Drive an SSD1306 I2C Display

1. Physical Connection

2. Coding

3. Running the Program

315MHz Remote Door Control by Windows 10 IoT

1. Remote control module

2. Stepper motor

3. Physical connection

4. Write code

5. Operation

Reed Controlled Light by Windows 10 IoT Core

1. Physical Connection

2. Coding

3. Running

74HC595 4 Digits LED Tube with Windows 10

1. Physical Connection

2. Coding

3. Running

Using stepper motor in Windows 10 IoT Core

1. Physical Connection

2. Write Code

Usage

3. Run

Sound Controlled Light by Windows 10 IoT Core

1. Calibration for FC-04 Sound Sensor

2. Connecting Raspberry Pi

3. Coding

4. Running

Windows 10 IoT: Detect Range with HC-04 Ultrasonic Sensor on Raspberry Pi 3

Windows 10 IoT Development: Moisture Sensor for Raspberry Pi 3

GY-30 (BH1750FVI) Light Sensor with Windows 10 IoT

Windows 10 IoT开发：UWP应用调用关机和重启命令

四、树莓派3的GPIO端口