This article provides an overview of developing skills for Misty. It describes how Misty works with your code, and it explores some of the differences between developing for Misty and developing for other platforms. It also provides guidelines for sharing skills and collaborating with other developers in the Misty Community.
At a high level, there are two ways to code your Misty II:
- You can build a skill using Misty's .NET SDK. A skill runs directly on the robot, alongside Misty's own software.
- You can build a robot application using Misty's HTTP API. The distinction between an application and a skill is that the code for an application runs on an external device (like your desktop browser or on a Raspberry Pi) and not onboard the robot.
While you can build many different types of skills and robot applications, most involve some combination of the following:
- gathering some of Misty's sensory data
- processing that data using Misty's API, or sending it off to a cloud service
- having Misty do something in response
For example, you might code Misty to do the following:
- roam an office to greet people she recognizes
- respond with sound and movement when you touch her on the head or chin
- patrol an area to capture photos, videos, and audio recordings while reporting changes in the environment
Misty's .NET, and HTTP APIs include many of the same commands, but they differ in architecture and implementation. The following sections provide a high-level overview of Misty's SDKs and APIs.
Misty II's .NET SDK provides tools for building, debugging, and deploying skills with Microsoft Visual Studio and the .NET framework. Skills you build with the .NET SDK assemble into background applications that run alongside Misty's software on Windows IoT Core. With Misty's .NET SDK, you can:
- Write skills in C#
- Leverage features of Visual Studio and the .NET framework such as autocomplete, IntelliSense, and live remote debugging
- Use external libraries in your skill code
- Test code before deployment by simulating input from sensors and other robot data
You build a .NET skill for Misty by wrapping your C# skill code in a background application and deploying the application to Misty's Windows 10 IoT Core device. Your skill code implements the interface and methods for issuing commands and getting data from the robot. You can read more about the architecture of a .NET skill in the .NET Skill Architecture documentation.
Currently, Misty's .NET SDK includes the following libraries and templates:
- Misty Skill Extension - A Visual Studio extension that contains project templates for C# skills. When you create a new project with this template, Visual Studio automatically installs the Misty Robotics SDK libraries for use in your skill.
- MistyRobotics.SDK - Library used to build .NET skills for Misty
- MistyRobotics.Common - Library with types and data objects commonly used across Misty's .NET skill projects
- MistyRobotics.Tools - Library with optional tools for programming Misty
Note: Comprehensive reference documentation for the public members of Misty's .NET SDK libraries is still under development. For now, we recommend using IntelliSense to browse the contents of the SDK libraries and access summaries of library classes and their members.
In addition to methods for using Misty's robot capabilities, Misty's .NET SDK libraries provide methods for:
- sending debug messages
- saving data to Misty
- handling data from sensor and skill events
- controlling the flow of your code's execution
- starting and stopping the execution of other skills on Misty
- simulating event data and command responses
Follow these links to learn more about coding with Misty's .NET SDK:
.NET skills run locally on Misty II. Consider using the .NET SDK when:
- you want to leverage the features of Visual Studio and the .NET framework
- you want to use external libraries for advanced local processing of input from Misty's sensors and other event data
- you want your skill to be portable, so that Misty can run it without depending on or requiring an external device
- you want to be able to package and share your functionality with other developers or Misty owners
- you need Misty to respond to commands immediately after they execute in your code
- your skill does not require input from another interface (like text from a computer)
With Misty's HTTP API, your code runs on an external device and makes HTTP requests to Misty over your local Wi-Fi connection. You send requests to Misty's HTTP API the same way you interact with other RESTful web APIs. The code you write to send these requests can execute from a web page, a microcontroller (like an Arduino), or any other device that can send web requests.
Writing a robot application with Misty's HTTP API typically involves two things:
- getting data from Misty's sensors via WebSocket connections
- sending requests to Misty's HTTP API endpoints
Code you write for Misty's HTTP API runs on a device outside Misty to send requests over your local Wi-Fi network. This can introduce some latency between the moment your skill sends a request and Misty's execution of the associated command.
It also means you can integrate the capabilities of the device from which the code executes into your skill. For example, if you use Misty's HTTP API to write skill for Misty to learn someone's face, you can design a web interface with a form where this person can type their name and send it to Misty.
Consider using Misty's HTTP API when:
- you want to write a skill for Misty using a language other than C#
- your skill depends on the integration of a graphic interface, like a web page
- your skill uses the capabilities of an external device that cannot communicate with Misty directly through her built-in UART serial port
- you prefer to work in a language that doesn't run natively on Misty
- the latency or network connectivity constraints when running from an external computer acre acceptable
Follow these links to learn more about Misty's HTTP API:
You can find helper libraries, code samples, wrappers, and other useful tools for skill development in the Misty Robotics Community on GitHub.
For examples of working skills that use a variety of Misty's capabilities, see Misty Skill Samples on GitHub.
For a collection of skills that other Misty II developers have shared, see the Misty Skills section of the community forums.
When you are ready to share a skill or application with other developers, you can post your code in the Misty Community Forums. Our recommendation for sharing skills and applications is as follows:
- Remove any passwords, credentials, API keys, or tokens your skill uses from your code.
- If your code uses 3rd party services, we recommend you create a
credentials.jsonfile where you can store the relevant details.
- To help your fellow developers, annotate your code in the places where the skill or application uses these accounts and credentials. You can list the details and instructions about how to acquire and use credentials in the skill in a
READMEfile in the same repository as the skill.
- If your code uses 3rd party services, we recommend you create a
- Create a repository that you maintain on GitHub or somewhere else where other developers can download your code.
- License your repository. You can use whichever license you'd like. For more information about choosing a license, see GitHub's article on Licensing a Repository.
- Create a new topic in the Misty Skills category of the Misty Community forums.
- Set the first post in your topic to be a wiki. This will allow you and other contributors to suggest changes to the original post as development on your skill continues.
- To set your post to be a wiki, select the three-dots icon from the menu below the post.
- Select the wrench icon.
- Select the Make Wiki option from the menu.
- Update the original post when you make changes to your code.