Using Raspberry Pi2 on Windows 10 IoT core has a number of challenges mainly due to the limitations of both the universal app APIs and also the lack of APIs that currently run on the platform. I specifically wanted to utilise Azure Service Bus Topics to send/receive messages on my Raspberry Pi2. After a bit of searching around I decided that the easiest way to achieve this was to use the Service Bus REST API. There are a number of samples included in the documentation:
Receiving a message: https://msdn.microsoft.com/en-us/library/azure/hh690923.aspx
Sending a message: https://msdn.microsoft.com/en-us/library/azure/hh690922.aspx
The full code for the sample uses WebClient but I needed to use HttpClient so I converted the samples accordingly.
[EDIT] The above links don't work anymore so I've published my code on GitHub https://github.com/sdspencer-mvp/RaspberryPi2-UnlockTheDoor/blob/master/UnlockTheDoor/MainPage.xaml.cs
Sending a message to the service bus requires a POST and receive and delete requires a DELETE. The following code shows how this was achieved using HttpClient
private async void SendMessage(string baseAddress, string queueTopicName, string token, string body, IDictionary<string, string> properties)
{
string fullAddress = baseAddress + queueTopicName + "/messages" + "?timeout=60&api-version=2013-08 ";
await SendViaHttp(token, body, properties, fullAddress, HttpMethod.Post);
}
// Receives and deletes the next message from the given resource (queue, topic, or subscription)
// using the resourceName and an HTTP DELETE request.
private static async System.Threading.Tasks.Task <string> ReceiveAndDeleteMessageFromSubscription(string baseAddress, string topic, string subscription, string token, IDictionary<string, string> properties)
{
string fullAddress = baseAddress + topic + "/Subscriptions/" + subscription + "/messages/head" + "?timeout=60";
HttpResponseMessage response = await SendViaHttp(token, "", properties, fullAddress, HttpMethod.Delete);
string content = "";
if (response.IsSuccessStatusCode)
{
// we should have retrieved a message
content = await response.Content.ReadAsStringAsync();
}
return content;
}
private static async System.Threading.Tasks.Task<HttpResponseMessage> SendViaHttp(string token, string body, IDictionary<string, string> properties, string fullAddress, HttpMethod httpMethod )
{
HttpClient webClient = new HttpClient();
HttpRequestMessage request = new HttpRequestMessage()
{
RequestUri = new Uri(fullAddress),
Method = httpMethod ,
};
webClient.DefaultRequestHeaders.Add("Authorization", token);
if (properties != null)
{
foreach (string property in properties.Keys)
{
request.Headers.Add(property, properties[property]);
}
}
request.Content = new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("", body) });
HttpResponseMessage response = await webClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
string error = string.Format("{0} : {1}", response.StatusCode, response.ReasonPhrase);
throw new Exception(error);
}
return response;
}
There was an issue with the GetSASToken method as some of the encryption classes weren't supported on the Universal App so I converted it to the following:
private string GetSASToken(string baseAddress, string SASKeyName, string SASKeyValue)
{
TimeSpan fromEpochStart = DateTime.UtcNow - new DateTime(1970, 1, 1);
string expiry = Convert.ToString((int)fromEpochStart.TotalSeconds + 3600);
string stringToSign = WebUtility.UrlEncode(baseAddress) + "\n" + expiry;
string hmac = GetSHA256Key(Encoding.UTF8.GetBytes(SASKeyValue), stringToSign);
string hash = HmacSha256(SASKeyValue, stringToSign);
string sasToken = String.Format(CultureInfo.InvariantCulture, "SharedAccessSignature sr={0}&sig={1}&se={2}&skn={3}",
WebUtility.UrlEncode(baseAddress), WebUtility.UrlEncode(hash), expiry, SASKeyName);
return sasToken;
}
public string HmacSha256(string secretKey, string value)
{
// Move strings to buffers.
var key = CryptographicBuffer.ConvertStringToBinary(secretKey, BinaryStringEncoding.Utf8);
var msg = CryptographicBuffer.ConvertStringToBinary(value, BinaryStringEncoding.Utf8);
// Create HMAC.
var objMacProv = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha256);
var hash = objMacProv.CreateHash(key);
hash.Append(msg);
return CryptographicBuffer.EncodeToBase64String(hash.GetValueAndReset());
}
This allowed me to send and receive messages on my Raspberry Pi2 using IoT core. I created the subscriptions for the topic using a separate app using the .NET SDK which is cheating I guess, but I’ll get around to converting it at some point.
In order to use this the following parameters are used:
SendMessage( BaseAddress, Username, Token, MessageBody, MessageProperties)
BaseAddress is “https://<yournamespace>.servicebus.windows.net/”
Token is the return value from the GetSASToken method. using the same base address as above and the KeyName and Key are obtained from the Azure portal and is of the format
Endpoint=sb://<yournamespace>.servicebus.windows.net/;SharedAccessKeyName=<KeyName>;SharedAccessKey=<Key>.
MessageBody – This is the string value of the message body
MessageProperties are a Dictionary containing name/value pairs that will get added to the Request headers. For example I have set the message properties when I press the door bell button on my Raspberry PI2
Dictionary<string, string> properties = new Dictionary<string, string>();
properties.Add("Priority", "High");
properties.Add("MessageType", "Command");
properties.Add("Command", "BingBong");
These are added to the service bus message and allow me to have subscriptions that filer on Command message types as well as the specific command of BingBong
Receiving messages are a bit trickier as we need to create a separate task that is continually running. Once the message is received we need to get back to the main tread to execute the action for the message
await Task.Run(async () =>
{
.
.
.
string message = await ReceiveAndDeleteMessageFromSubscription(_BaseAddress
,_TopicName
, _SubscriptionName
, token, null);
if (message.Contains("Unlock"))
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
() =>
{
SwitchLED(false);
});
}
.
.
}
You may want to put a delay in this if receiving the messages causes the app to slow down due to the message loop hogging all the resources. There’s a default timeout in the call to SendAsync and this will automatically slow the thread down.
I now have a working Raspberry PI2 that can send and receive message to the Azure Service bus. I’ve created a test win forms app that allows me to send messages to the Service bus and it allows me to control the Raspberry Pi2 remotely. The next phase is to build a workflow engine that hooks up to the service bus and allows me to automatically control the Raspberry Pi.