Workshop 09

Workshop 09 - Application

← Home

Mocking a Robot

Modern robots can communicate through REST APIs. Thus, they could receive specific commands: MoveTo(x,y,z), Stop(), GetStatus() etc.
Sometimes, they do not directly "understand" REST, but instead rely on specific robotic middleware solutions (e.g. Robot Operating System - ROS2).
In such cases, an intermediary microservice can be created to facilitate communication between external applications and robots. The microservice will further communicate with the robot using specific protocols (ROS 2 native bindings, WebSocket bridge, gRPC, etc.).
It is important to notice gRPC is a language agnostic, high-performance Remote Procedure Call (RPC) framework. gRPC has strong support in the Microsoft .NET ecosystem.
Humans can communicate with robots through Human Machine Interface Desktop or Web applications (HMI).

Solution architecture

In this workshop we'll create a REST service that mimics a robot API.
A HMI application will be designed for assuring humans communications with the REST service.
Thus, we will create a .Net solution containing the following projects:

A Class Library project (the Robot Mock)
An ASP.NET Core Web API project (the Robot REST API)
A Windows Forms App project (the HMI desktop client)
A MSTest Test project

Specifications

Commands:

- Status (HTTP GET)
  - Ready, Busy, and Error (with error code and error message)

- Position (HTTP GET)
  - Returns a JSON containing the (X,Y) coordinates

- Forward(distance) => Back(distance) = Forward(-distance) (HTTP PUT)
  - Movement resolution = 1m
  - The robot will work at a speed of 1 m/s (in more advanced scenarios, the speed could also be changed using a dedicated command)

- Right(angle) => Left(angle) = Right(-angle) (HTTP PUT)
  - Rotation resolution = 5 deg
  - The robot will work at an angular velocity of 5 degrees/s

- Emergency Stop (HTTP PUT)
  - The robot will stop any movement as soon as possible

Application Rules:

  - While busy, the robot will ignore any movement commands, except for Emergency Stop
  - While busy, the robot will respond to get requests (Status & Position)

Nice to have:

- The robot will be equipped with various sensors/devices e.g.:
  - obstacle detection (distance to the obstacle and angular size)
  - image acquisition

Creating a Human Machine Interface (HMI)

In this section we'll create a Windows Forms "control panel" for the previously described robot mock.

Display

- Position and Orientation: the robot will be represented as an arrow on a Picturebox control (nice to have: real-time).

- Coordinates and Status: will be displayed on a multi-line Textbox (nice to have: real-time).

Commands:

- Forward/Back Buttons with a corresponding Textbox for providing the distance parameter:
  - As previously mentioned, the service will ignore any command while the robot is busy
  - If command accepted, the task duration will be estimated. The status and position will be requested after the estimated time elapsed.
  - The graphical representation will be updated accordingly

- Left/Right Buttons with a corresponding Textbox for providing the angle parameter:
  - The service will ignore any command while the robot is busy
  - If command accepted, the task duration will be estimated. The status and position will be requested after the estimated time elapsed.
  - The graphical representation will be updated accordingly

- Emergency Stop Button

Observation!

The HMI project could also make use of various technologies and frameworks:
- Machine Learning (e.g. the Microsoft ML.Net library) functionalities: the HMI app could receive and analyze images acquired by the robot;
- Generative AI (GenAI) / Large Language Model (LLM) (e.g. OpenAI REST services) for translating human readable text into robot commands;
- Quantum Computing Services for solving classically intractable problems, etc.

Implementation

Robo Mock (Class Library Project)

Entities & Helpers:

	
public enum StatusEnum
{
	Ready = 0,
	Busy = 1,
	Error = 2
}

public class StatusInfo
{
	public StatusEnum Status { get; set; }
	public string Msg { get; set; }

	// Orientation
	public double Alpha { get; set; }

	// Position
	public double X { get; set; }
	public double Y { get; set; }
}

public class CommandResponse
{
	public bool Accepted { get; set; }
	public StatusInfo Status { get; set; }
}

internal static class MathExt
{
	public static double DegToRad(double deg)
	{
		var rad = (deg  / 180) * Math.PI;   
		return rad;
	}

	public static double RadToDeg(double rad)
	{
		var deg = (rad / Math.PI) * 180;
		return deg;
	}
}

internal class Time
{
	public static void Delay(TimeSpan time)
	{
		var crtDate = DateTime.Now;
		while(DateTime.Now.Subtract(time) < crtDate)
		{

		}
	}
}

Robo:

	

public interface IRobo
{
	StatusInfo GetStatus();
	CommandResponse AskForward(int distance);
	CommandResponse AskRight(int alpha);
	void EmergencyStop();
}

/// <summary>
/// RoboMock is implementing the IRobo interface
/// </summary>
public class RoboMock : IRobo
{
    private object _statusLock = new object();
    private StatusInfo _status;
    private bool _emergencyStop;

    public RoboMock()
    {
        _status = new StatusInfo()
        {
            Status = StatusEnum.Ready,
            Alpha = 0,
            X = 0,
            Y = 0,
        };
    }

    public StatusInfo GetStatus()
    {
        return _status;
    }

    public bool IsBusy
    {
        get
        {
            return _status.Status == StatusEnum.Busy;
        }
    }

    public bool IsReady
    {
        get
        {
            return _status.Status == StatusEnum.Ready;
        }
    }

    public CommandResponse GetRejectResponse()
    {
        var response = new CommandResponse()
        {
            Accepted = false,
            Status = _status
        };
        return response;
    }

    public CommandResponse GetAcceptResponse()
    {
        var response = new CommandResponse()
        {
            Accepted = true,
            Status = _status
        };
        return response;
    }

    public void WaitOneSec()
    {
        Time.Delay(TimeSpan.FromSeconds(1));
    }

    public void EmergencyStop()
    {
        _emergencyStop = true;
    }

    /// <summary>
    /// If accepted => triggers moving FD
    /// </summary>
    /// <param name="distance"></param>
    /// <returns></returns>
    public CommandResponse AskForward(int distance)
    {
        if (!IsReady)
        {
            return GetRejectResponse();
        }

        lock (_statusLock)
        {
            if (!IsReady)
            {
                return GetRejectResponse();
            }
            _status.Status = StatusEnum.Busy;
        }

        Task.Run(() => 
            Forward(distance)
        );

        return GetAcceptResponse();
    }

    /// <summary>
    /// Simulates moving forward with 1m/s velocity 
    /// </summary>
    /// <param name="distance"></param>
    public void Forward(int distance)
    {
        for (int x = 1; x <= Math.Abs(distance); x++)
        {
            if (_emergencyStop)
            {
                _emergencyStop = false;
                break;
            }
            WaitOneSec();
            lock (_statusLock)
            {
                var rad = MathExt.DegToRad(_status.Alpha);
                var step = Math.Sign(distance);
                _status.Y += step * Math.Cos(rad);
                _status.X += step * Math.Sin(rad);
            }
        }

        lock (_statusLock)
        {
            _status.Status = StatusEnum.Ready;
        }
    }

    /// <summary>
    /// If accepted => triggers rotating RT
    /// </summary>
    /// <param name="alpha"></param>
    /// <returns></returns>
    public CommandResponse AskRight(int alpha)
    {
        if (!IsReady)
        {
            return GetRejectResponse();
        }

        lock (_statusLock)
        {
            if (!IsReady)
            {
                return GetRejectResponse();
            }
            _status.Status = StatusEnum.Busy;
        }

        Task.Run(() =>
            Right(alpha)
        );

        return GetAcceptResponse();
    }

    /// <summary>
    /// Simulates rotating right with 5 degrees/s angular velocity 
    /// </summary>
    /// <param name="alpha"></param>
    public void Right(int alpha)
    {
        for (int x = 0; x < Math.Abs(alpha); x+=5)
        {
            if (_emergencyStop)
            {
                _emergencyStop = false;
                break;
            }
            WaitOneSec();
            lock (_statusLock)
            {
                _status.Alpha += Math.Sign(alpha) * 5;
            }
        }

        lock (_statusLock)
        {
            _status.Status = StatusEnum.Ready;
        }
    }

}

Robo REST API (Web API Project)

The Robo Controller:

	
// IRobo is injected as Singleton (Program.cs)
// builder.Services.AddSingleton<IRobo, RoboMock>();

[ApiController]
[Route("api/robo")]
public class RoboController : ControllerBase
{
	private IRobo _robo;

	private readonly ILogger<RoboController> _logger;

	public RoboController(
		ILogger<RoboController> logger,
		IRobo robo
	)
	{
		_logger = logger;
		_robo = robo;
	}

	
	[HttpGet("status")]
	public StatusInfo Get()
	{
		var status = _robo.GetStatus();
		return status;  
	}


	[HttpPut("fd/{distance}")]
	public CommandResponse Put(int distance)
	{
		var response = _robo.AskForward(distance);
		return response;
	}

	[HttpPut("rt/{alpha}")]
	public CommandResponse PutRt(int alpha)
	{
		var response = _robo.AskRight(alpha);
		return response;
	}

	[HttpPut("stop")]
	public void PutStop()
	{
		_robo.EmergencyStop();
	}
}

Robo HMI (Windows Forms Project)

Model:

	
public class CommandResponse
{
	public bool Accepted { get; set; }
	public StatusInfo Status { get; set; }
}

public class StatusInfo
{
	public int Status { get; set; }
	public string Msg { get; set; }

	// Orientation
	public double Alpha { get; set; }

	// Position
	public double X { get; set; }
	public double Y { get; set; }
}

REST API Client:

	
public partial class ControlPanel : Form
{
	const string API_URL = @"http://localhost:5278/api/";

	private readonly HttpClient _httpClient = new HttpClient();

	public ControlPanel()
	{
		InitializeComponent();
	}

	public void DrawTurtle()
	{
		// ToDo: draw a triangle corresponding to the robot position and orientation
	}

	private string GetStatusDescription(int status)
	{
		switch (status)
		{
			case 0:
				return "Ready";
			case 1:
				return "Busy";
			case 2:
				return "Error";
			default:
				return "Unknown";
		}
	}

	private async void buttonGetStatus_Click(object sender, EventArgs e)
	{
		try
		{
			var url = $"{API_URL}robo/status";
			var response = await _httpClient.GetFromJsonAsync<StatusInfo>(url);

			var alpha = (float)response.Alpha;
			var x = (float)(5 * response.X);
			var y = (float)(5 * response.Y);

			var info = new StringBuilder();
			info.AppendLine(GetStatusDescription(response.Status));
			info.AppendLine($"({Math.Round(response.X, 2)}, {Math.Round(response.Y, 2)}) - {alpha}");
			info.AppendLine(response.Msg);
			textBoxInfo.Text = info.ToString();

			_turtle.SetAlpha(alpha);
			_turtle.SetXY(x, y);

			DrawTurtle();
		}
		catch (Exception ex)
		{
			textBoxInfo.Text = ex.Message;
		}
	}

	private async void buttonFD_Click(object sender, EventArgs e)
	{
		try
		{
			var distance = int.Parse(textBoxCmdParam.Text);
			var url = $"{API_URL}robo/fd/{distance}";
			var response = await _httpClient.PutAsync(url, null);

			response.EnsureSuccessStatusCode();
			var result = await response.Content.ReadFromJsonAsync<CommandResponse>();
			textBoxInfo.Text = result.Accepted ? $"FD({distance}) Accepted" : $"FD({distance}) Refused";
		}
		catch (Exception ex)
		{
			textBoxInfo.Text = ex.Message;
		}
	}
	
	private async void buttonBack_Click(object sender, EventArgs e)
	{
		try
		{
			var distance = -1 * int.Parse(textBoxCmdParam.Text);
			var url = $"{API_URL}robo/fd/{distance}";
			var response = await _httpClient.PutAsync(url, null);

			response.EnsureSuccessStatusCode();
			var result = await response.Content.ReadFromJsonAsync<CommandResponse>();
			textBoxInfo.Text = result.Accepted ? $"BK({-distance}) Accepted" : $"FD({distance}) Refused";
		}
		catch (Exception ex)
		{
			textBoxInfo.Text = ex.Message;
		}
	}

	private async void buttonRT_Click(object sender, EventArgs e)
	{
		try
		{
			var alpha = int.Parse(textBoxCmdParam.Text);
			var url = $"{API_URL}robo/rt/{alpha}";
			var response = await _httpClient.PutAsync(url, null);

			response.EnsureSuccessStatusCode();
			var result = await response.Content.ReadFromJsonAsync<CommandResponse>();
			textBoxInfo.Text = result.Accepted ? $"RT({alpha}) Accepted" : $"FD({alpha}) Refused";
		}
		catch (Exception ex)
		{
			textBoxInfo.Text = ex.Message;
		}
	}
	
	private async void buttonLT_Click(object sender, EventArgs e)
	{
		try
		{
			var alpha = -1 * int.Parse(textBoxCmdParam.Text);
			var url = $"{API_URL}robo/rt/{alpha}";
			var response = await _httpClient.PutAsync(url, null);

			response.EnsureSuccessStatusCode();
			var result = await response.Content.ReadFromJsonAsync<CommandResponse>();
			textBoxInfo.Text = result.Accepted ? $"LT({-alpha}) Accepted" : $"FD({alpha}) Refused";
		}
		catch (Exception ex)
		{
			textBoxInfo.Text = ex.Message;
		}
	}

	private async void buttonStop_Click(object sender, EventArgs e)
	{
		try
		{
			var url = $"{API_URL}robo/stop";
			var response = await _httpClient.PutAsync(url, null);

			response.EnsureSuccessStatusCode();
			textBoxInfo.Text = "Emergency stop successfully sent!";
		}
		catch (Exception ex)
		{
			textBoxInfo.Text = ex.Message;
		}
	}

	private void buttonMonitor_Click(object sender, EventArgs e)
	{
		while (checkBoxMonitor.Checked)
		{
			Application.DoEvents();
			buttonGetStatus_Click(null, null);
			System.Threading.Thread.Sleep(500);
		}
	}
}

References:

Create web APIs with ASP.NET Core
Overview of gRPC in .NET
SignalR
Machine Learning .NET
.NET Multi-platform App UI

← Home