Forem: Dave Glover

Build an Air Pollution Monitor with a Raspberry Pi, a Particulate Matter sensor and IoT Central

Dave Glover — Fri, 24 Jul 2020 01:26:20 +0000

Build an Air Pollution Monitor with a Raspberry Pi, a Particulate Matter sensor and IoT Central

Background

Born of necessity, this project tracked the air quality over Sydney during the height of the Australian bush fires. I wanted to gauge when it was safe to go outside, or when it was better to close up the apartment and stay in for the day.

Sydney, Dec 2019	Particulate matter readings
	Readings for PM 2.5 and PM 10 approx 1000. Healthy levels should be between 0 ~ 10.

This is Sydney on a clear day, the photo was taken in May 2020, alas, during the COVID-19 pandemic lock down. On the upside, there is close to zero air pollution.

#JulyOT

This is part of the #JulyOT IoT Tech Community series, a collection of blog posts, hands-on-labs, and videos designed to demonstrate and teach developers how to build projects with Azure Internet of Things (IoT) services. Please also follow #JulyOT on Twitter.

Introduction

In this hands-on lab, you will learn how to create and debug a Python application on a Raspberry Pi with Visual Studio Code and the Remote SSH extension. The app requires the Pimoroni Enviro+ pHAT, and reads data from the PMS5003 particulate matter (PM) and BME280 sensors and streams the data to Azure IoT Central.

Parts required

Raspberry Pi 2 or better, SD Card, and Raspberry Pi power supply
Pimoroni Enviro+ pHAT
PMS5003 Particulate Matter Sensor with Cable available from Pimoroni and eBay.

This lab depends on Visual Studio Code and Remote SSH development. Remote SSH development is supported on Raspberry Pis built on ARMv7 chips or better. The Raspberry Pi Zero is built on ARMv6 architecture. The Raspberry Pi Zero is capable of running the solution, but it does not support Remote SSH development.

Solution Architecture

Let's get started

Head to Raspberry Pi Air Pollution Monitor

There are five modules covering the following topic

Module 1: Create an Azure IoT Central application
Module 2: Set up your Raspberry Pi
Module 3: Set up your development environment
Module 4: Run the solution
Module 5: Dockerize the Air Quality Monitor solution

Source code

All source code available for the Raspberry Pi Air Pollution monitor

Acknowledgements

This tutorial builds on the Azure IoT Python SDK 2 samples.

Have fun and stay safe and be sure to follow us on #JulyOT.

Build Raspberry Pi .NET Core IoT Applications running on Raspberry Pi OS or Ubuntu 20.04

Dave Glover — Thu, 23 Jul 2020 04:38:29 +0000

Follow me on Twitter @dglover

#JulyOT

Operating Systems and ARM architectures supported

This tutorial has been tested with .NET Core applications running on Raspberry Pi OS and Ubuntu 20.04 (including Ubuntu Mate 20.04) for both 32bit (ARM32) and 64bit (ARM64). The projects also include build tasks for Debug and Release configurations.

Source Code

The source and the samples for this tutorial can be found here.

Examples

The examples are found in the samples director of this repo and cover the following .NET Core scenarios.

Simple hello world: dotnet.core.iot.csharp
Azure IoT Hub: dotnet.core.iot.csharp.iothub
.NET Core Web API: dotnet.core.iot.csharp.webapi
.NET Core Web App: dotnet.core.iot.csharp.webapp
Azure IoT Hub or IoT Central with DPS (Device Provisioning Service): dotnet.core.iot.csharp.dps.iot
Azure IoT device twins: dotnet.core.iot.csharp.dps.iot.device-twins
Azure IoT Hub device twins, and Pi Sense HAT: dotnet.core.iot.csharp.dps.iot.device-twins.sense.hat
Simple Pi Sense HAT Sample: dotnet.core.iot.csharp.sense.hat 9: F# and .NET Core: dotnet.core.iot.fsharp

Tips and Tricks for setting up Ubuntu 20.04 on a Raspberry Pi

Check out the following Raspberry Pi Tips and Tricks to boot Ubuntu from USB3 SSD, how to overclock, enable WiFi, and support for the Raspberry Pi Sense HAT.

Introduction

The .NET Core IoT Library connects your applications to hardware. In this tutorial you will learn how to:

Develop a C# .NET Core IoT application from your Linux, macOS or Windows 10 computer,
Streamline the develop, deploy, and debug process using Visual Studio Code,
Use the .NET Core IoT library to read the CPU temperature. The CPU temperature will be used to represent the room temperature in this lab scenario,
Stream temperature telemetry to Azure IoT Hub,
Control a remote HVAC system.

Raspberry Pi Hardware

.Net Core requires an AMR32v7 processor and above, so anything Raspberry Pi 2 or better and you are good to go. Note, Raspberry Pi Zero is an ARM32v6 processor, and is not supported.

The Raspberry Pi 3a Plus is a great device for .NET Core.

I'm super happy with my Raspberry Pi 4B 4GB and 8GB devices seen here dress with a heatsink case.

I like to use Raspberry Pi OS Lite as it takes less resources than the full Raspberry Pi Desktop version and I do all my Raspberry Pi development from my computer.

If you've not set up a Raspberry Pi before then this is a great guide. "Setting up a Headless Pi". Be sure to use the WiFi network as your development computer.

If you are not comfortable setting up Raspberry Pi OS Lite (Headless), then follow the Setting up your Raspberry Pi guide to set up the full Raspberry Pi OS Desktop version.

Optional Hardware

The Raspberry Pi Sense HAT has builtin sensors and a LED panel. If you have one then great, one of the labs uses this HAT.

Why .NET Core

It used by millions of developers, it is mature, fast, supports multiple programming languages (C#, F#, and VB.NET), runs on multiple platforms (Linux, macOS, and Windows), and is supported across multiple processor architectures. It is used to build device, cloud, and IoT applications.

.NET Core is an open-source, general-purpose development platform maintained by Microsoft and the .NET community on GitHub.

Learning C#

There are lots of great resources for learning C#. Check out the following:

The .NET Core IoT Libraries Open Source Project

The Microsoft .NET Core team along with the developer community are building support for IoT scenarios. The .NET Core IoT Library is supported on Linux, and Windows IoT Core, across ARM and Intel processor architectures. See the .NET Core IoT Library Roadmap for more information.

System.Device.Gpio

The System.Device.Gpio package supports general-purpose I/O (GPIO) pins, PWM, I2C, SPI and related interfaces for interacting with low-level hardware pins to control hardware sensors, displays and input devices on single-board-computers; Raspberry Pi, BeagleBoard, HummingBoard, ODROID, and other single-board-computers that are supported by Linux and Windows 10 IoT Core.

Iot.Device.Bindings

The .NET Core IoT Repository contains IoT.Device.Bindings, a growing set of community-maintained device bindings for IoT components that you can use with your .NET Core applications. If you can't find what you need then porting your own C/C++ driver libraries to .NET Core and C# is pretty straight forward too.

The drivers in the repository include sample code along with wiring diagrams. For example the BMx280 - Digital Pressure Sensors BMP280/BME280.

Raspberry Pi .NET Core Developer Learning Path

Have fun and stay safe and be sure to follow us on #JulyOT.

Build a Rover combining the best of Azure Sphere security with FreeRTOS

Dave Glover — Wed, 22 Jul 2020 03:40:20 +0000

Build a Rover combining the best of Azure Sphere security with FreeRTOS

What you will learn

You will learn how to integrate a Real-time FreeRTOS application responsible for running a timing-sensitive ultrasonic distance sensor with the security and cloud connectivity of Azure Sphere.

#JulyOT

Source code and learning resources

Source code: Azure Sphere seeing eyed rover Real-time FreeRTOS sensors and Azure IoT.

Learning resources: Azure Sphere Developer Learning Path.

Learn more about Azure Sphere

Azure Sphere is a comprehensive IoT security solution – including hardware, OS, and cloud components – to actively protect your devices, your business, and your customers.

Azure Sphere is made up of three interrelated components:

Azure Sphere-certified MCUs
Azure Sphere OS
Azure Sphere Security Service

Azure Sphere Architecture

The Azure Sphere is built on the Mediatec MT3620. This crossover MCU consists of 5 cores. There is a dedicated communications core, a dedicated Security Subsystem core, and three user application cores.

The three applications cores are as follows:

1 x ARM Cortex A7 core running Embedded Linux (built with Yokto), exposing a set of POSIX APIs. Developers can build and deploy a High-level application to this core. This core is also responsible for the TrustZone Security Monitor, threat detection reporting, and OS and Application life cycle management.
2 x ARM Cortex M4Fs. Developers can build and deploy Real-time applications to these cores. Real-time applications can be built against the bare metal or built using Real-time frameworks such as FreeRTOS and Azure RTOS.

With Visual Studio (free community edition or better) or Visual Studio Code, you can develop and debug applications running on all three cores. For example, you can simultaneously debug an app running on the A7 core and a M4 core FreeRTOS app.

Application architecture

The application running on the Azure Sphere consists of two parts.

Real-time FreeRTOS Application

The Real-time FreeRTOS application running on one of the M4 cores that is responsible for running the timing-sensitive HC-SR04 ultrasonic distance sensor.
Distance is measured every 100 milliseconds so the rover can decide the best route.
The sensor requires precise microsecond timing to trigger the distance measurement process, so it is a perfect candidate for running on the Real-time core as a FreeRTOS Task.
Every 5 seconds a FreeRTOS Task sends distance telemetry to the Azure Sphere A7 High-level application.

Azure IoT High-level Application

The application running on the Azure Sphere A7 High-level application core is responsible for less timing-sensitive tasks such as establishing WiFi/Network connectivity, negotiating security and connecting with Azure IoT Central, updating the device twin and send telemetry messages.

Extending

I am thinking about extending this solution with a local TinyML module for smarter navigation.

Parts list

1 x Seeed Studio Seeed Studio MT3620 Mini Dev Board
1 x MT3620 Grove Breakout
2 x Grove - Ultrasonic Distance Sensor
1 x H-Bridge driver. Seeed Studio have a Grove - I2C Motor Driver, or you can wire up your own H-Bridge connector to the Grove Breakout board.
1 x Rover chassis, motors, wheels etc

Azure IoT Central

Azure IoT Central provides an easy way to connect, monitor, and manage your Internet of Things (IoT) assets at scale.

I created a free trial of Azure IoT Central and in no time I had the rover distance sensor charted and available for deeper analysis. By the way, you can continue to connect two devices for free to IoT Central after the trial period expires.

Extend and integrate Azure IoT Central applications with other cloud services

Azure IoT Central is also extensible using rules and workflows. For more information, review Use workflows to integrate your Azure IoT Central application with other cloud services

How to build the solution

Set up your Azure Sphere development environment.
Review Integrate FreeRTOS Real-time room sensors with Azure IoT.
Learn how to connect and Azure Sphere to Azure IoT Central or Azure IoT Hub.
The IoT Central Device Template Capabilities Model JSON file for this solution is included in the iot_central directory of this repo.

Have fun and stay safe and be sure to follow us on #JulyOT.

Improve health, wellbeing, and productivity by tracking your home workspace CO2 levels

Dave Glover — Fri, 17 Jul 2020 11:23:27 +0000

Improve health, wellbeing, and productivity by tracking your home workspace CO2 levels

How to build a healthier working environment by monitoring CO2, temperature, and humidity levels with an Azure Sphere device, an SDC30 sensor, and Azure IoT Central.

#JulyOT

Are CO2 levels making you grumpy, sleepy, or sad

Working from home it is easy to close the door to shut out the noise of everyday life while we get on with work. Closing the door can lead to a build-up of CO2 gas, a by-product of our breathing, which can impact our wellbeing, concentration, and productivity levels.

Check out "Indoor carbon dioxide levels could be a health hazard, scientists warn".

The problem is we cannot see or smell Carbon Dioxide, it just keeps building up, and we have no way of knowing it is happening other than getting tired or a headache. So, with that in mind, I figured it was the Internet of Things to the rescue!

The solution

I wanted to build a secure IoT device with Azure Sphere using the Seeed Studio Grove CO2 & Temperature & Humidity Sensor sensor I had in my box of bits. The folks at Sensirion made it super easy to port their SCD30 driver to Azure Sphere. It was just a matter of implementing the I2C init/read/write functions, a microsecond sleep function, plus setting up CMake build. It all just worked. The ported driver is included in this project.

Azure IoT Central

Azure IoT Central provides an easy way to connect, monitor, and manage your Internet of Things (IoT) assets at scale.

I created a free trial of Azure IoT Central and in no time I had CO2, temperature, and humidity telemetry displayed (yes, the data is real, so we have made some changes at home!). By the way, you can continue to connect two devices for free to IoT Central after the trial period expires.

Parts list

The solution supports two configurations.

Seeed Studio Azure Sphere Mini Dev Board

Seeed Studio Seeed Studio MT3620 Mini Dev Board
MT3620 Grove Breakout
Seeed Studio Grove CO2 & Temperature & Humidity Sensor
Optional, 3 x Grove LEDs, or a Grove Relay to drive a bigger warning light!

AVNET Azure Sphere Starter Kit

AVNET Azure Sphere Starter Kit
Seeed Studio Grove CO2 & Temperature & Humidity Sensor
Optional, 1 x Click Relay to drive a bigger warning light.

Get started

Follow the complete guide to "Track CO2 levels in your workspace to improve health, wellbeing, and productivity"

Learning resources

Learning resources: Azure Sphere Developer Learning Path.

Have fun, stay safe, and be sure to follow us on #JulyOT.

Introducing Azure Sphere Developer Learning Path Labs on GitHub

Dave Glover — Wed, 29 Apr 2020 04:55:32 +0000

IoT security is a critical challenge touching every aspect of our lives. Security is complex, expensive, and ever-changing as hackers become more cunning. Azure Sphere builds on decades of Microsoft and industry security experience with a unique blend of hardware, device and cloud services that enables you to create “Secure by default” IoT solutions.

The Azure Sphere Developer Learning Path is a series of labs designed to ease you into the world of Azure Sphere development with the Avnet and Seeed Studio Azure Sphere development boards.

The labs cover Azure Sphere security concepts, secure bi-directional cloud communications, how to integrate FreeRTOS Real-Time applications with the Azure, and over the air updates, with more labs to follow.

Learn more about Azure Sphere

These labs include several libraries used to abstract underlying complexity allowing you to focus on the problems you are trying to solve with cleaner and more manageable code. You are free to use these libraries in your projects and contribute back.

Start, or reignite your Azure Sphere development projects and learn how to build “Secure by Default” IoT solutions with the “Azure Sphere Developer Learning Path” labs.

Learning Modules

Learn more about "The Seven Properties of Highly Secure Devices".

For questions and support head to Azure Sphere Support.

Skippy, Kenny, and Willy need our help - Day 17 of the #25DaysOfServerless Challenge

Dave Glover — Thu, 19 Dec 2019 12:26:24 +0000

This article is part of #25DaysOfServerless. New challenges will be published every day from Microsoft Cloud Advocates throughout the month of December. Find out more about how Microsoft Azure enables your Serverless functions.

Have an idea or a solution? Share your thoughts on Twitter!

Time for an Australian Christmas day BBQ on the beach.

Skippy the Kangaroo, and his mates, Kenny the Koala, and Willy the Wombat were very excited and looking forward to Christmas. ‘Only one more sleep’ said Kenny the Koala, ‘I have been very good all year’. Skippy and Willy looked at each other and rolled their eyes, ‘you have not been that good’ they thought. Skippy reminded his mates, ‘it’s not all about presents, my favourite part of Christmas is going to the beach, firing up the BBQ, having a nice cold beer, and relaxing with my friends and family. Let’s hope it a sunny day’.

Write an Internet or Things Serverless solution that helps Skippy, Kenny, and Willy know if it’s a warm day at the beach. You can use the Raspberry Pi Simulator (or a real Raspberry Pi) to send temperature data to Azure IoT Hub to trigger a Python Azure Function. The Azure Function will send a tweet to let our friends know the temperate is greater than 31 degrees (88 Fahrenheit) and it is time to head to the beach for a truly Australian Christmas day.

Create an Azure IoT Hub, Register a device and Test

The Azure IoT Raspberry Pi Simulator is a great way to get started building an Azure IoT Solution.

Follow the documentation to Connect Raspberry Pi online simulator to Azure IoT Hub. When you create an Azure IoT Hub be sure to select the Free Tier.

Event Hub Connection Information

When you have created your Azure IoT Hub then navigate to the Azure IoT Hub Built-in endpoints blade. You will need the Event Hub compatible name and the Event Hub compatible endpoint when you create the Python Azure Function.

Create a Python Azure Function

Install the following Visual Studio Code extensions

Follow the Tutorial: Create a Python function for Azure Functions tutorial.

Select Python as the language for the function project
Optional, but recommended, create a virtual environment
Select Azure Event Hub trigger
Name your Event Hub Trigger
Create new local app settings
Select your subscription
When prompted to select an event hub namespace select Skip for now
Paste the Azure IoT Hub Event Hub compatible name as the name of the event hub from which to trigger.glovebox-iothub 9 Select the $Default Event Hub consumer group

Configure the Azure IoT Hub Connection String

When the Visual Studio Code has finished creating the project open the function.json file. The connection property will be an empty string. Modify the value of the connection property to IotHubConnectionString.

Create the IoT Hub Connection String Environment Variable

Open the local.settings.json file and create a new property named IotHubConnectionString and set the value to the Azure IoT Hub Event Hub compatible endpoint.

Start the Azure Storage Local Emulator

Azure Functions need access to Azure Storage Emulator for logging and checkpointing. When developing functions it can be fast to use the Azure Storage Local Emulator.

To Install:

On Windows install and start the Azure storage emulator
On macOS and Linux install and start Azurite

Test the Python Azure Function

Now is a great time to test the Python Azure Function is triggered by new messages sent from the Raspberry Pi Simulator.

Ensure the Raspberry Pi Simulator is running and sending telemetry. Configure the Azure IoT Hub Device Connection string and click Run.
Open the init.py file and set a breakpoint on line 7.
Press F5 to start the Azure Function from Visual Studio Code.
The Function will start and when a collection of messages arrive from Azure IoT hub the breakpoint will be hit.

Process the Incoming Messages

Replace the Python code in the init.py file with the following code.

import logging
import json
import os
import azure.functions as func

def main(event: func.EventHubEvent):

    data = event.get_body().decode('utf-8')
    telemetry = json.loads(data)

    for item in telemetry:
        temperature = item.get("temperature")
        if temperature is not None and type(temperature) is float and 31 < temperature < 40:
            print(temperature)

The Python telemetry object is an array of JSON objects. The code loops through the JSON collection and validates that the temperature object is of type float and greater than 31 and less than 40.

Integrating the Azure Function with Twitter

Follow the Getting started with the Twitter API documentation.

Create a Twitter Application.
Add the Twitter authorisation information to the local.settings.json file rather than the auth.py.

Load these environment variables when your Python Function starts and add

python from twython import Twython

to the function.

import logging
import json
from twython import Twython
import os
import azure.functions as func

consumer_key = os.environ["consumer_key"]
consumer_secret = os.environ["consumer_secret"]
access_token = os.environ["access_token"]
access_token_secret = os.environ["access_token_secret"]

def main(event: func.EventHubEvent):

    data = event.get_body().decode('utf-8')
    telemetry = json.loads(data)

    for item in telemetry:
        temperature = item.get("temperature")
        if temperature is not None and type(temperature) is float and 31 < temperature < 40:
            print(temperature)

Install twython Python Twitter Library

1.

bash pip3 install twython

Add twython to the project requirements file. This will be needed when you package up the solution and deploy to Azure.

Integrate with Twitter

Update the Pthyon code in the init.py file as follows:

import logging
import json
from twython import Twython
import os
import azure.functions as func

consumer_key = os.environ["consumer_key"]
consumer_secret = os.environ["consumer_secret"]
access_token = os.environ["access_token"]
access_token_secret = os.environ["access_token_secret"]

twitter = Twython(
    consumer_key,
    consumer_secret,
    access_token,
    access_token_secret
)

def sendTwitterMsg():
    message = "Hey Skippy, Kenny, and Willy, time for an Australian Christmas Day on the beach #25DaysOfServerless"
    try:
        twitter.update_status(status=message)
    except:
        logging.info("problem tweeting from the Python Function")
        logging.info("Tweeted: %s" % message)

def main(event: func.EventHubEvent):

    data = event.get_body().decode('utf-8')
    telemetry = json.loads(data)

    for item in telemetry:
        temperature = item.get("temperature")
        if temperature is not None and type(temperature) is float and 31 < temperature < 40:
            print(temperature)

Save the changes
Set a breakpoint in the

python def sendTwitterMsg():

function.
Press F5 to rerun the function.
Ensure the Raspberry Pi Simulator is running and sending telemetry
Check Twitter, you should see your message telling Skippy, Kenny, and Willy they should head to the beach.

Finished 完了 fertig finito ख़त्म होना terminado

Want to submit your solution to this challenge? Build a solution locally and then PR this repo. If your solution doesn't involve code you can record a short video and submit it as a PR to the same repo. Make sure to tell us which challenge the solution is for. We're excited to see what you build! Do you have comments or questions? Add them to the comments area below.

Watch for surprises all during December as we celebrate 25 Days of Serverless. Stay tuned here on dev.to as we feature challenges and solutions! Sign up for a free account on Azure to get ready for the challenges!

Create a Secure Azure Sphere App using the Grove Shield Sensor Kit

Dave Glover — Tue, 17 Dec 2019 05:46:59 +0000

Follow me on Twitter @dglover

Author	Dave Glover, Microsoft Cloud Developer Advocate
Target Platform	Seeed Studio Azure Sphere MT3620
Developer Platform	Windows 10 or Ubuntu 18.04
Azure SDK	Azure Sphere SDK 19.11 or better
Developer Tools	Visual Studio (The free Community Edition or better) or Visual Studio Code (Free OSS)
Hardware	Seeed Studio Grove Shield, and the Grove Temperature and Humidity Sensor (SHT31)
Language	C
Date	As of December, 2019

What is Azure Sphere

Azure Sphere is a secured, high-level application platform with built-in communication and security features for internet-connected devices.

It comprises a secured, connected, crossover microcontroller unit (MCU), a custom high-level Linux-based operating system (OS), and a cloud-based security service that provides continuous, renewable security.

Hardware Required

This tutorial requires the Seeed Studio Azure Sphere, the Seeed Studio Grove Shield, and the Grove Temperature and Humidity Sensor (SHT31). These parts are available from many online stores including Seeed Studio.

Be sure to plug the Grove Temperature Sensor into one of the I2C connectors on the Grove Shield.

Set up your Development Environment

This tutorial assumes Windows 10 and Visual Studio (The free Community Edition or better). For now, Azure Sphere templates are only available for Visual Studio. However, you can clone and open this solution on Windows and Ubuntu 18.04 with Visual Studio Code.

Follow the Azure Sphere Overview of set up procedures guide.

Azure Sphere SDK

This tutorial assumes you are using the Azure Sphere SDK 19.11 or better which uses the CMake Build System.

This tutorial uses a fork of the Seeed Studio Grove Shield Library that has been updated to support Azure Sphere SDK 19.11.

Clone the MT3620 Grove Shield Library

Create a folder where you plan to build your Azure Sphere applications.
Clone the MT3620 Grove Shield Library.

Open a command window and change to the directory where you plan to build your Azure Sphere applications.
```
git clone https://github.com/gloveboxes/MT3620_Grove_Shield.git
```

Create a new Visual Studio Azure Sphere Project

Start Visual Studio and create a new project in the same directory you cloned the MT3620 Grove Shield Library.

It is important to create the Visual Studio Project in the same folder you cloned the MT3620 Grove Shield as there are relative links to this library in the application you will create.

azure-sphere
    |- MT3620_Grove_Shield
    |- YourAzureSphereApplication

Select Azure Sphere Project Template

Type sphere in the search box and select the Azure Sphere Blink template.

Configure new Azure Sphere Project

Name the project and set the save location.

Open the CMakeLists.txt file

CMakelists.txt defines the build process, the files and locations of libraries and more.

Add a Reference to MT3620_Grove_Shield_Library

Two items need to be added:

The source location on the MT3620 Grove Shield library. Note, this is the relative path to the Grove Shield library.
Add MT3620_Grove_Shield_Library to the target_link_libraries definition. This is equivalent to adding a reference.

Set the Application Capabilities

The application manifest defines what resources will be available to the application. Define the minimum set of privileges required by the application. This is core to Azure Sphere security and is also known as the Principle of least privilege.

Review the Grove Shield Sensor Capabilities Quick Reference to understand what capabilities are required for each sensor in the library.
Open app_manifest.json
Add Uart ISU0
- Note, access to the I2C SHT31 temperature/humidity sensor via the Grove Shield was built before Azure Sphere supported I2C. Hence calls to the sensor are proxied via the Uart.
Note, GPIO 9 is used to control an onboard LED.

{
  "SchemaVersion": 1,
  "Name": "AzureSphereBlink1",
  "ComponentId": "a3ca0929-5f46-42b0-91ba-d5de1222da86",
  "EntryPoint": "/bin/app",
  "CmdArgs": [],
  "Capabilities": {
    "Gpio": [ 9 ],
    "Uart": [ "ISU0" ],
    "AllowedApplicationConnections": []
  },
  "ApplicationType": "Default"
}

Update the Code

The following code includes the Grove Sensor headers, opens the Grove Sensor, and the loops reading the temperature and humidity and writes this information to the debugger logger.

Replace all the existing code in the main.c file with the following:

#include <signal.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>

#include <applibs/log.h>
#include <applibs/gpio.h>

// Grove Temperature and Humidity Sensor
#include "../MT3620_Grove_Shield/MT3620_Grove_Shield_Library/Grove.h"
#include "../MT3620_Grove_Shield/MT3620_Grove_Shield_Library/Sensors/GroveTempHumiSHT31.h"

static volatile sig_atomic_t terminationRequested = false;

static void TerminationHandler(int signalNumber)
{
    // Don't use Log_Debug here, as it is not guaranteed to be async signal safe
    terminationRequested = true;
}

int main(int argc, char* argv[])
{
    Log_Debug("Application starting\n");

    // Register a SIGTERM handler for termination requests
    struct sigaction action;
    memset(&action, 0, sizeof(struct sigaction));
    action.sa_handler = TerminationHandler;
    sigaction(SIGTERM, &action, NULL);

    // Change this GPIO number and the number in app_manifest.json if required by your hardware.
    int fd = GPIO_OpenAsOutput(9, GPIO_OutputMode_PushPull, GPIO_Value_High);
    if (fd < 0) {
        Log_Debug(
            "Error opening GPIO: %s (%d). Check that app_manifest.json includes the GPIO used.\n",
            strerror(errno), errno);
        return -1;
    }

    // Initialize Grove Shield and Grove Temperature and Humidity Sensor
    int i2cFd;
    GroveShield_Initialize(&i2cFd, 115200);
    void* sht31 = GroveTempHumiSHT31_Open(i2cFd);

    const struct timespec sleepTime = { 1, 0 };
    while (!terminationRequested) {

        GroveTempHumiSHT31_Read(sht31);
        float temp = GroveTempHumiSHT31_GetTemperature(sht31);
        float humi = GroveTempHumiSHT31_GetHumidity(sht31);
        Log_Debug("Temperature: %.1fC\n", temp);
        Log_Debug("Humidity: %.1f\%c\n", humi, 0x25);

        GPIO_SetValue(fd, GPIO_Value_Low);
        nanosleep(&sleepTime, NULL);

        GPIO_SetValue(fd, GPIO_Value_High);
        nanosleep(&sleepTime, NULL);
    }
}

Deploy the Application to the Azure Sphere

Connect the Azure Sphere to your computer via USB
Ensure you have claimed, connected, and developer enabled your Azure Sphere.
Select GDB Debugger (HLCore) from the Select Startup dropdown.
From Visual Studio, press F5 to build, deploy, start, and attached the remote debugger to the Azure Sphere.

View the Debugger Output

Open the Output window to view the output from Log_Debug statements in main.c.

You can do this by using the Visual Studio Ctrl+Alt+O keyboard shortcut or click the Output tab found along the bottom/right of Visual Studio.

Set a Debug Breakpoint

Set a debugger breakpoint by clicking in the margin to the left of the line of code you want the debugger to stop at.

In the main.c file set a breakpoint in the margin of the line that reads the Grove temperature and pressure sensor GroveTempHumiSHT31_Read(sht31);.

Stop the Debugger

Stop the debugger by using the Visual Studio Shift+F5 keyboard shortcut or click the Stop Debugging icon.

Azure Sphere Application Cloud Deployment

Now you have learnt how to "Side Load" an application onto Azure Sphere it is time to learn about the Deployment Basics to Cloud Deploy an application.

Finished 完了 fertig finito ख़त्म होना terminado

Congratulations, you created a secure Internet of Things Azure Sphere application.

Appendix

Grove Shield Sensor Capabilities Quick Reference

Sensors	Socket	Capabilities
Grove Light Sensor	Analog	"Gpio": [ 57, 58 ], "Uart": [ "ISU0"]
Grove Rotary Sensor	Analog	"Gpio": [ 57, 58 ], "Uart": [ "ISU0"]
Grove 4 Digit Display	GPIO0 or GPIO4	"Gpio": [ 0, 1 ] or "Gpio": [ 4, 5 ]
Grove LED Button	GPIO0 or GPIO4	"Gpio": [ 0, 1 ] or "Gpio": [ 4, 5 ]
Grove Oled Display 96x96	I2C	"Uart": [ "ISU0"]
Grove Temperature Humidity SHT31	I2C	"Uart": [ "ISU0"]
Grove UART3	UART3	"Uart": [ "ISU3"]
LED 1	Red Green Blue	"Gpio": [ 8 ] "Gpio": [ 9 ] "Gpio": [ 10 ]
LED 2	Red Green Blue	"Gpio": [ 15 ] "Gpio": [ 16 ] "Gpio": [ 17 ]
LED 3	Red Green Blue	"Gpio": [ 18 ] "Gpio": [ 19 ] "Gpio": [ 20 ]
LED 4	Red Green Blue	"Gpio": [ 21 ] "Gpio": [ 22 ] "Gpio": [ 23 ]

For more pin definitions see the mt3620_rdb.h in the MT3620_Grove_Shield/MT3620_Grove_Shield_Library folder.

Azure Sphere Grove Kit

Azure Sphere	Image
Azure Sphere MT3620 Development Kit
Azure Sphere MT3620 Development Kit Shield. Note, you can also purchase the parts separately.

Azure Sphere MT3620 Developer Board Pinmap

The full Azure Sphere MT3620 Board Pinmap can be found on the Azure Sphere MT3620 Development Kit page.

Part 1: Build a Kubernetes "Intelligent Edge" Cluster on Raspberry Pi

Dave Glover — Tue, 22 Oct 2019 04:19:39 +0000

Follow me on Twitter @dglover

Introduction

Building a Kubernetes Intelligent Edge cluster on Raspberry Pi is a great learning experience, a stepping stone to building robust Intelligent Edge solutions, and an awesome way to impress your friends. Skills you develop on the edge can be used in the cloud with Azure Kubernetes Service.

The Kubernetes cluster is built with Raspberry Pi 4 nodes and is very capable. It has been tested with Python and C# Azure Functions, Azure Custom Vision Machine Learning models, and the NGINX Web Server.

This project forms the basis for a four-part Intelligence on the Edge series. The followup topics will include:

Build, debug, and deploy Python and C# Azure Functions to a Raspberry Pi Kubernetes Cluster, and learn how to access hardware from a Kubernetes managed container.
Developing, deploying and managing Intelligence on the Edge with Azure IoT Edge on Kubernetes.
Getting started with the dapr.io, an event-driven, portable runtime for building microservices on cloud and edge.

System Configuration

The Kubernetes cluster set up is fully scripted and well documented.

Head to Building a Kubernetes Intelligent Edge Cluster on Raspberry Pi on GitHub to learn more.

Python for Beginners Learning Series on YouTube

Dave Glover — Tue, 01 Oct 2019 05:44:47 +0000

If you are starting your Python developer journey then be sure to check out the new "Python for Beginners Learning Series" on YouTube. It's free and a great place to get started.

For more information on the training series then be sure to read the "A new video series for beginners to learn Python programming" announcement on the Microsoft Open Source Blog.

Raspberry Pi, Azure IoT Central, and Docker Container Debugging

Dave Glover — Fri, 27 Sep 2019 08:20:19 +0000

PyLab 2: Raspberry Pi, Azure IoT Central, and Docker Container Debugging

Follow me on Twitter @dglover

Author	Dave Glover, Microsoft Cloud Developer Advocate
Platforms	Linux, macOS, Windows, Raspbian Buster
Services	Azure IoT Central
Tools	Visual Studio Code
Hardware	Raspberry Pi, Raspberry Pi Sense HAT
Language	Python
Date	September, 2019

PDF Lab Guide

You may find it easier to download and follow the PDF version of the Raspberry Pi, Python, Azure IoT Central, and Docker Container Debugging PyLab.

PyLab Content

Introduction

In this hands-on lab, you will learn how to create a Python Internet of Things (IoT) application with Visual Studio Code. Run the application in a Docker Container on a Raspberry Pi, read temperature, humidity, and air pressure telemetry from a sensor, and finally debug the application running in the Docker Container.

PyLab Set Up

Single-User Set Up

This automated set up installs the required libraies, Docker, and builds the lab docker images.

Multi-User Set Up

The Multi-user set up allows up to 20 users/students per Raspberry Pi 4 4GB. A USB3 SSD drive is required to support the disk IO requirements for this number of users. The installation script installs the lab content, and Docker. Builds the lab Docker Images, and sets up all the users.

Software Installation

This hands-on lab uses Visual Studio Code. Visual Studio Code is a code editor and is one of the most popular Open Source projects on GitHub. It runs on Linux, macOS, and Windows.

Install Visual Studio Code

Install Visual Studio Code

Visual Studio Code Extensions

The features that Visual Studio Code includes out-of-the-box are just the start. VS Code extensions let you add languages, debuggers, and tools to your installation to support your development workflow.

Browse for extensions

You can search and install extensions from within Visual Studio Code. Open the Extensions view from the Visual Studio Code main menu, select View > Extensions or by clicking on the Extensions icon in the Activity Bar on the side of Visual Studio Code.

This will show you a list of the most popular VS Code extensions on the VS Code Marketplace.

Install the Python, Remote SSH, and Docker Extensions

Search and install the following two Visual Studio Code Extensions published by Microsoft.

Remote SSH Development

The Visual Studio Code Remote - SSH extension allows you to open a remote folder on any remote machine, virtual machine, or container with a running SSH server and take full advantage of Visual Studio Code.

Raspberry Pi Hardware

You need the following information:

The Network Address of the Raspberry Pi
Your Raspberry Pi login name and password.

SSH Authentication with private/public keys

Setting up a public/private key pair for SSH authentication is a secure and fast way to authenticate from your computer to the Raspberry Pi. This is recommended for this hands-on lab.

SSH Set up for Windows Users

The SSH utility guides you through the process of setting up a secure SSH channel for Visual Studio Code and the Raspberry Pi.

You will be prompted for:

The Raspberry Pi Network IP Address,
The Raspberry Pi login name and password

From Windows File Explorer, open ftp://<Raspberry Pi Address>
Copy the scripts directory to your desktop
Open the scripts folder you copied to your desktop
Double click the windows-setup-ssh.cmd

SSH Set up for Linux and macOS Users

The SSH utility guides you through the process of setting up a secure SSH channel for Visual Studio Code and the Raspberry Pi

You will be prompted for:

The Raspberry Pi Network IP Address,
The Raspberry Pi login name and password

Open a Terminal window

Copy and paste the following command, and press ENTER

read -p "Enter the Raspberry Pi Address: " pyurl && \
curl ftp://$pyurl/scripts/ssh-setup.sh | bash

Start a Remote SSH Connection

Start Visual Studio Code
Press F1 to open the Command Palette, type ssh connect and select Remote-SSH: Connect to Host
Select the pylab-devnn configuration
Check the Remote SSH has connected.

It will take a moment to connect, then the SSH Status in the bottom lefthand corner of Visual Studio Code will change to >< SSH:pylab-devnn. Where devnn is your Raspberry Pi Login name.

Introduction to Docker

Jake Wright's Docker in 12 Minutes is a great introduction to Docker.

Open the PyLab 2 Docker Debug Project

From Visual Studio Code main menu: File > Open Folder
Select the PyLab directory
Next select, the PyLab-2-Docker-Debug/ directory
Click OK to Open the directory
From the Explorer bar, open the app folder, then the app.py file, and review the contents

Creating an Azure IoT Central Application

We are going to create an Azure IoT Central application, then a device, and finally a device connection string needed for the application that will run in the Docker container.

Create a New IoT Central Application

Open the Azure IoT Central in a new browser tab, then click Getting started.
Next, you will need to sign with your Microsoft Personal, or Work, or School account. If you do not have a Microsoft account, then you can create one for free using the Create one! link.
Create a new Azure IoT Central application, select New Application. This takes you to the Create Application page.
Select Trail, Custom application, name your IoT Central application and complete the sign-up information.

Click Create Device Templates, then select the Custom template, name your template, for example, Raspberry. Then click Create
Edit the Template, add Measurements for Temperature, Humidity, and Pressure telemetry.

Measurements are the data that comes from your device. You can add multiple measurements to your device template to match the capabilities of your device.

Telemetry measurements are the numerical data points that your device collects over time. They're represented as a continuous stream. An example is temperature.
Event measurements are point-in-time data that represents something of significance on the device. A severity level represents the importance of an event. An example is a fan motor error.
State measurements represent the state of the device or its components over a period of time. For example, a fan mode can be defined as having Operating and Stopped as the two possible states.
Location measurements are the longitude and latitude coordinates of the device over a period of time in. For example, a fan can be moved from one location to another.

Use the information in the following table to set up three telemetry measurements. The field name is case-sensitive.

You must click Save after each measurement is defined.

Display Name	Field name	Units	Minimum	Maximum
Humidity	Humidity	%	0	100
Temperature	Temperature	degC	-10	60
Pressure	Pressure	hPa	800	1260

The following is an example of setting up the Temperature telemetry measurement.

Click Device on the sidebar menu, select the Raspberry template you created.

IoT central supports real devices, such as the Raspberry Pi used for this lab, as well as simulated devices which generate random data useful for system testing.
Select Real.

Name your Device ID so you can easily identify the device in the IoT Central portal, then click Create.
When you have created your real device click the Connect button in the top right-hand corner of the screen to display the device credentials.

Leave this page open as you will need this connection information for the next step in the hands-on lab.

Generate an Azure IoT Hub Connection String

Hold the control key down and click the following link Connection String Generator to open in a new tab.

Copy and paste the Scope Id, Device Id, and the Primary Key from the Azure IoT Central Device Connection panel to the Connection String Generator page and click Get Connection String.
Copy the generated connection string to the clipboard as you will need it for the next step.

Configure the Python Application

Switch back to Visual Studio Code. Open the env-file (environment file). This file contains environment variables that will be passed to the Docker container.
Paste the connection string you copied in the previous step into the env-file on the same line, and after CONNECTION_STRING=.

For example:
```
CONNECTION_STRING=HostName=saas-iothub-8135cd3b....
```
Save the env-file file (Ctrl+S)

Build and Run the Docker Image

Press F5 to start debugging the Python application. The process will first build and then start the Docker Container. When the Docker Container has started the Visual Studio Code Debugger will attach to the running application.

There are two configuration files found in the .vscode folder that are responsible for running and debugging the Python application. You can find more detail the Debugger Configuration appendix.

Set a Visual Studio Debugger Breakpoint

From Explorer on the Visual Studio Code activity bar, open the app.py file
Set a breakpoint at line 66, temperature, pressure, humidity, timestamp = mysensor.measure() in the publish function.

You can set a breakpoint by doing any one of the following:
- With the cursor on that line, press F9, or,
- With the cursor on that line, select the Debug > Toggle Breakpoint menu command, or, click directly in the margin to the left of the line number (a faded red dot appears when hovering there). The breakpoint appears as a red dot in the left margin:

Debug actions

Once a debug session starts, the Debug toolbar will appear at the top of the editor window.

The debugger toolbar (shown above) will appear in Visual Studio Code. It has the following options:

Pause (or Continue, F5),
Step Over (F10)
Step Into (F11),
Step Out (Shift+F11),
Restart (Ctrl+Shift+F5),
and Stop (Shift+F5).

Step through the Python code

Press F10, or from the Debugger Toolbar, click Step Over until you are past the print(telemetry) line of code.
Explore the Variable Window (Ctrl+Shift+Y). Try changing variable values.
Explore the Debug Console. You will see sensor telemetry and the results of sending the telemetry to Azure IoT Central.
From the Debug Menu -> Disable All Breakpoints
Press F5 or from the Debugger Toolbar, click Continue so the Python application runs and streams telemetry to Azure IoT Central.

Exploring Device Telemetry in Azure IoT Central

Use Device to navigate to the Measurements page for the real Raspberry Pi device you added:
On the Measurements page, you can see the telemetry streaming from the Raspberry Pi device:

Finished

Appendix

Debugger Configuration

There are two files (launch.json and tasks.json) found in the .vscode folder that are responsible for the running and debugging the application.

Launch Configuration

Creating a launch configuration file is useful as it allows you to configure and save debugging setup details.

launch.json

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Attach Debugger",
            "preLaunchTask": "start-docker",
            "postDebugTask": "stop-docker",
            "type": "python",
            "request": "attach",
            "pathMappings": [
                {
                    "localRoot": "${workspaceRoot}/app",
                    "remoteRoot": "/app"
                }
            ],
            "port": "${env:LAB_PORT}",
            "host": "localhost"
        },
        {
            "name": "Stop Container",
            "preLaunchTask": "stop-docker",
            "type": "python",
            "request": "launch"
        }
    ]
}

Tasks Configuration

Tasks integrate external tools to automate build cycle.

tasks.json

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "start-docker",
            "type": "shell",
            "command": "sh",
            "args": [
                "-c",
                "\"docker build -t $USER:latest . ;docker run -d -p $LAB_PORT:3000 -e TELEMETRY_HOST=$LAB_HOST --env-file env-file --name $USER --rm  $USER:latest; sleep 1 \""
                // -d Run container in background and print container ID,
                // -p maps the $LAB_PORT to port 3000 in the container, this port is used for debugging,
                // -e Environment Variable. The IP Address of the telemetry service.
                // --env-file reads from a file and sets Environment Variables in the Docker Container,
                // --name names the Docker Container
                // --rm removes the container when you stop it
                // Docker run reference https://docs.docker.com/engine/reference/run/
            ],
        },
        {
            "label": "stop-docker",
            "type": "shell",
            "command": "sh",
            "args": [
                "-c",
                "\"docker stop $USER\""
            ]
        }
    ]
}

Azure IoT Central

Take a tour of the Azure IoT Central UI

This article introduces you to the Microsoft Azure IoT Central UI. You can use the UI to create, manage, and use an Azure IoT Central solution and its connected devices.

As a builder, you use the Azure IoT Central UI to define your Azure IoT Central solution. You can use the UI to:

Define the types of device that connect to your solution.
Configure the rules and actions for your devices.
Customize the UI for an operator who uses your solution.

As an operator, you use the Azure IoT Central UI to manage your Azure IoT Central solution. You can use the UI to:

Monitor your devices.
Configure your devices.
Troubleshoot and remediate issues with your devices.
Provision new devices.

Use the left navigation menu

Use the left navigation menu to access the different areas of the application. You can expand or collapse the navigation bar by selecting < or >:

Search, help, and support

The top menu appears on every page:

To search for device templates and devices, enter a Search value.
To change the UI language or theme, choose the Settings icon.
To sign out of the application, choose the Account icon.
To get help and support, choose the Help drop-down for a list of resources. In a trial application, the support resources include access to live chat.

You can choose between a light theme or a dark theme for the UI:

Dashboard

The dashboard is the first page you see when you sign in to your Azure IoT Central application. As a builder, you can customize the application dashboard for other users by adding tiles. To learn more, see the Customize the Azure IoT Central operator's view tutorial. Users can also create their own personal dashboards.

Device explorer

The explorer page shows the devices in your Azure IoT Central application grouped by device template.

A device template defines a type of device that can connect to your application. To learn more, see the Define a new device type in your Azure IoT Central application.
A device represents either a real or simulated device in your application. To learn more, see the Add a new device to your Azure IoT Central application.

Device sets

The device sets page shows device sets created by the builder. A device set is a collection of related devices. A builder defines a query to identify the devices that are included in a device set. You use device sets when you customize the analytics in your application. To learn more, see the Use device sets in your Azure IoT Central application article.

Device Templates

The device templates page is where a builder creates and manages the device templates in the application. To learn more, see the Define a new device type in your Azure IoT Central application tutorial.

Analytics

The analytics page shows charts that help you understand how the devices connected to your application are behaving. An operator uses this page to monitor and investigate issues with connected devices. The builder can define the charts shown on this page. To learn more, see the Create custom analytics for your Azure IoT Central application article.

Jobs

The jobs page allows you to perform bulk device management operations onto your devices. The builder uses this page to update device properties, settings, and commands. To learn more, see the Run a job article.

Continuous Data Export

The continuous data export page is where an administrator defines how to export data, such as telemetry, from the application. Other services can store the exported data or use it for analysis. To learn more, see the Export your data in Azure IoT Central article.

Administration

The administration page contains links to the tools an administrator uses such as defining users and roles in the application. To learn more, see the Administer your Azure IoT Central application article.

References

Raspberry Pi, Debugging a Python Internet of Things Application

Dave Glover — Fri, 27 Sep 2019 08:05:56 +0000

PyLab 1: Raspberry Pi, Debugging a Python Internet of Things Application

Follow me on Twitter @dglover

Author	Dave Glover, Microsoft Cloud Developer Advocate
Platforms	Linux, macOS, Windows, Raspbian Buster
Services	Azure IoT Central
Tools	Visual Studio Code
Hardware	Raspberry Pi, Raspberry Pi Sense HAT
Language	Python
Date	September, 2019

PDF Lab Guide

You may find it easier to download and follow the PDF version of the Debugging Raspberry Pi Internet of Things Flask App PyLab.

PyLab Content

Introduction

In this hands-on lab, you will learn how to create and debug a Python web application on a Raspberry Pi with Visual Studio Code and the Remote SSH extension. The web app will read the temperature, humidity, and air pressure telemetry from a sensor connected to the Raspberry Pi.

PyLab Set Up

Single-User Set Up

This automated set up installs the required libraies, Docker, and builds the lab docker images.

Multi-User Set Up

Software Installation

This hands-on lab uses Visual Studio Code. Visual Studio Code is a code editor and is one of the most popular Open Source projects on GitHub. It runs on Linux, macOS, and Windows.

Install Visual Studio Code

Install Visual Studio Code

Visual Studio Code Extensions

Browse for extensions

This will show you a list of the most popular VS Code extensions on the VS Code Marketplace.

Install the Python and Remote SSH Extensions

Search and install the following two Visual Studio Code Extensions published by Microsoft.

Python
Remote - SSH

Remote SSH Development

Raspberry Pi Hardware

If you are attending a workshop, then you can use a shared network-connected Raspberry Pi. You can also use your own network-connected Raspberry Pi for this hands-on lab.

You will need the following information from the lab instructor.

The Network IP Address of the Raspberry Pi
Your assigned login name and password.

SSH Authentication with private/public keys

Setting up a public/private key pair for SSH authentication is a secure and fast way to authenticate from your computer to the Raspberry Pi. This is recommended for this hands-on lab.

SSH Set up for Windows Users

The SSH utility guides you through the process of setting up a secure SSH channel for Visual Studio Code and the Raspberry Pi.

You will be prompted for:

The Raspberry Pi Network IP Address,
The Raspberry Pi login name and password

From Windows File Explorer, open ftp://<Raspberry Pi Address>
Copy the scripts directory to your desktop
Open the scripts folder you copied to your desktop
Double click the windows-setup-ssh.cmd

SSH Set up for Linux and macOS Users

The SSH utility guides you through the process of setting up a secure SSH channel for Visual Studio Code and the Raspberry Pi

You will be prompted for:

The Raspberry Pi Network IP Address,
The Raspberry Pi login name and password

Open a Terminal window

Copy and paste the following command, and press ENTER

read -p "Enter the Raspberry Pi Address: " pyurl && \
curl ftp://$pyurl/scripts/ssh-setup.sh | bash

Start a Remote SSH Connection

Start Visual Studio Code
Press F1 to open the Command Palette, type ssh connect and select Remote-SSH: Connect to Host
Select the pylab-devnn configuration
Check the Remote SSH has connected.

It will take a moment to connect, then the SSH Status in the bottom lefthand corner of Visual Studio Code will change to >< SSH:pylab-devnn. Where devnn is your Raspberry Pi Login name.

Open PyLab 1 Python Debug Project

Python Flask Web Apps

In this lab, we are going to start and debug a Flask app that reads a sensor attached to the Raspberry Pi. Flask is a popular Python Web Framework, powerful, but also easy for beginners.

From Visual Studio Code main menu: File > Open Folder
Select the PyLab directory
Next select, the PyLab-1-Python-Debug directory
Click OK to Open the directory
From the Explorer bar, open the app.py file and review the contents

Take a moment to review the Python Flask web app.

app.py

from flask import Flask, abort, render_template
from datetime import datetime
import telemetry_client
# import sensor_bme280
import time

# myTelemetry = sensor_bme280.Telemetry()
myTelemetry = telemetry_client.Telemetry()
app = Flask(__name__)


@app.route('/')
def show_telemetry():

    now = datetime.now()
    formatted_now = now.strftime("%A, %d %B, %Y at %X")

    title = "Raspberry Pi Environment Data"

    temperature, pressure, humidity, timestamp, cpu_temperature = myTelemetry.measure()

    sensor_updated = time.strftime(
        "%A, %d %B, %Y at %X", time.localtime(timestamp))

    if -40 <= temperature <= 60 and 0 <= pressure <= 1500 and 0 <= humidity <= 100:
        return render_template('index.html', title=title,
                            temperature=temperature, pressure=pressure,
                            humidity=humidity, cputemperature=cpu_temperature)
    else:
        return abort(500)

Start the Python Flask App

Press F5 to start the Python Flask app.
From the Visual Studio Code Terminal Window, click the running on http://... web link.
This will launch your desktop Web Browser.

-  The Flask app will read the temperature, air pressure, humidity from the sensor attached the Raspberry Pi and display the results in your web browser.

<br/>

Debugging with Breakpoints

Switch back to Visual Studio Code and ensure the app.py file is open.
Put the cursor on the line that reads now = datetime.now()
Press F9 to set a breakpoint. A red dot will appear on the line to indicate a breakpoint has been set.
Switch back to the Web Browser and click Refresh. The web page will not respond as the debugger has stopped at the breakpoint you set.
Switch back to Visual Studio Code. You will see that the code has stopped running at the breakpoint.

Debugger Toolbar Options

When a debug session starts, the Debug toolbar will appear at the top of the editor window.

The debugging toolbar (shown below) will appear in Visual Studio Code. It has the following options:

Pause (or Continue, F5),
Step Over (F10)
Step Into (F11),
Step Out (Shift+F11),
Restart (Ctrl+Shift+F5),
and Stop (Shift+F5).

Start Debugging

Step through the code by pressing (F10) or clicking Step Over on the debugging toolbar.
Repeat pressing F10 until you reach the line that reads if -40 <= temperature <= 60 and 0 <= pressure <= 1500 and 0 <= humidity <= 100:
You will notice that Python variables are displayed in the Variables Window.

If the Variable Window is not visible click Debug in the activity bar.
Try to change the temperature variable to 50. Hint, right mouse click on the temperature variable and select Set Value, or double click on a temperature variable.
Press F5 to resume the Flask App, then switch back to your web browser and you will see the temperature, humidity, and pressure Sensor data displayed on the web page.

Debugging with Conditional Breakpoints

Try setting a conditional breakpoint

Clear the existing breakpoints. From the main menu select Debug > Remove all breakpoints.
Ensure the app.py file open.
Right mouse click directly in the margin to the left of the line number 22.
Select Add Conditional Breakpoint...
Set the condition to temperature > 25, then press ENTER

The breakpoint appears as a red dot with an equals sign in the middle
Switch back to the Web Browser and click Refresh. The web page will not respond as the debugger has stopped at the breakpoint you set.
Switch back to Visual Studio Code and you will see the debugger has stopped at the conditional breakpoint.
Press F5 to continue running the code
Switch back to your web browser to view the page.

Interactive Debug Console

The Visual Studio Code Debug Console will give you access to the Python REPL (Read, Evaluate, Print Loop).

Switch back to your web browser and click refresh. The web page will not respond as the Python code has been stopped by the debugger.
Switch back to Visual Studio Code
The code will have stopped at the conditional breakpoint you previously set.
Select the Visual Studio Debug Console window.
Type the following Python code into the Input Prompt >
```
print(temperature)
```
Press Enter to execute the Python code you typed.
Try running the following Python code snippets from the input prompt.
```
temperature = 24
import random
random.randrange(100, 1000)
```
Press F5 to continue the execution of the Python code.
Switch back to you web browser to see the updated page.

Lab Challenges

Lab Challenge 1: Update the Flask Template

Update the Flask index.html template found in the templates folder to display the current date and time.
Rerun the Flask app.

Lab Challenge 2: Experiment with Debugger Options

Things to try:

Review the Visual Studio Code Python Tutorial
Review the Python Flask tutorial
Review the Visual Studio Code Debugging Tutorial

Review the Debug Launch Settings

Switch to Debug view in Visual Studio Code (using the left-side activity bar).
Click the Settings button which will open the launch.json file.
The launch.json file defines how the Flask app will start, and what Flask Command Line parameters to pass at startup.

There are two environment variables used in the launch.json file. These are LAB_HOST (which is the IP Address of the Raspberry Pi), and LAB_PORT (a random TCP/IP Port number between 5000 and 8000). These environment variables are set by the .bashrc script which runs when you connect to the Raspberry Pi with Visual Studio Remote SSH.

Closing the Remote SSH Session

From Visual Studio Code, Close Remote Connection.

Click the Remote SSH button in the bottom left-hand corner and select Close Remote Connection from the dropdown list.