Dismantling microservices: When .NET Core encounters steering gear control

Do you have a piece of equipment that requires precise control? For example, a robotic arm that relies on a servo to rotate an angle, or a set of conveyor belts driven by servo motors. They run very well, but every time you want to adjust the speed, change the action process, or even just monitor real-time data, you have to re-burn the firmware and restart the system - is it a bit of a headache?

It's like every appliance in your home has to be controlled individually without a master switch. As time goes by, it becomes more and more tiring to operate.

So let’s talk about microservices. Don’t be scared by this word, it is actually breaking a large software into several independent small modules, each module is only responsible for one thing. For example, one module is responsible for steering gear angle calculation, and the other only handles motion trajectory planning. They "chat" and collaborate through the Internet. The advantage of this is that if you change one of the modules, the others will be almost unaffected.

Why has .NET Core C# become the choice of many people?

Imagine that the control program you previously wrote on Windows now wants to be transplanted to an embedded Linux device to run. What should you do? In the past, you might have to rewrite a lot of code. And .NET Core allows you to use the same C# code to run across Windows, Linux and even macOS. For those scenarios where an industrial PC or Raspberry Pi is used as the control core, there is suddenly a lot less repetitive work.

Moreover, C# has clear syntax and mature asynchronous programming. These features quietly help a lot when you need to monitor data from multiple sensors at the same time and ensure that the servo control instructions are not stuck.

The transformation from "big housekeeper" to "group leader"

Traditionally, a monolithic program does everything: read sensors, calculate logic, issue control commands, and record logs. Once the number of functions increases, the program is like an ever-expanding room, with things piling up and becoming more cluttered.

Microservices divide a room into small compartments with clear functions. For example, you can split it like this:

• Motion control services: Only focus on receiving the target angle and output PWM signal to the servo.
• route planning service: Calculate a smooth motion curve based on the task.
• Status monitoring service: Collect data such as temperature and load, and alarm when the threshold is exceeded.

Each service communicates through lightweight HTTP or message queue. If a service fails, it usually does not affect the operation of other services. When upgrading, you can replace path plans individually without having to bring down the entire system.

It's like modular design in machinery - if you need a certain gear set, you don't have to dismantle the entire machine.

What does this bring about in a machine control scenario?

Be flexible. You can first use a service to implement basic reciprocating motion of the servo, and then slowly add a visual recognition service later so that the robotic arm can "see" and adjust the grabbing position. Each time a new feature is added, it is like plugging and unplugging a building block.

It is fault tolerant. If the status monitoring service is temporarily disconnected due to network fluctuations, the motion control service can still continue to work according to the received instructions to avoid sudden equipment shutdown. Such "weak dependencies" are valuable when designing highly reliable systems.

Another is the freedom of technological heterogeneity. The core motion control service can be written in C#, and if it is more convenient to use Python, the machine learning part can be completely independent as another service. They can collaborate by agreeing on the data format.

But microservices are not a silver bullet. If the service is split too finely, the communication overhead will increase; debugging in a distributed environment is also more complicated than that of a single one. So the usual advice is: start splitting from the core bottleneck. For example, the most complex part of your mechanical system is the trajectory, then separate it into a service first.

How to take the first step?

You don’t have to aim for a perfect split from the beginning. You can extract a relatively independent functional module from the existing single program and change it into a service that can be called through the network. For example, first separate the logging function and let it receive log messages from other modules through HTTP.

.NET Core provides a wealth of tools to simplify this process. You can use ASP.NET Core to quickly build a lightweight Web API as a service endpoint, use Docker containers to encapsulate environmental dependencies, and then use some middleware to handle service discovery and load balancing.

During the process, you will encounter issues such as data consistency and timeout processing between services, which all need to be adjusted according to the actual scenario. But the important thing is that you start to organize your code in a more loosely coupled way, which often has more advantages than disadvantages for long-term maintenance.

Just like adjusting the mechanical structure, sometimes it is not to increase speed immediately, but to make subsequent modifications smoother.

In the final analysis, technology selection ultimately serves the problem you want to solve. Microservice is an architectural idea, and .NET Core is one of the implementation tools. When your device control logic becomes more and more complex, and when frequent updates and expansions become the norm, this decoupled thinking may help you reduce a lot of maintenance burden.

Good architecture does not make simple things complicated, but makes complicated things sustainable.

Established in 2005,kpowerhas been dedicated to a professional compact motion unit manufacturer, headquartered in Dongguan, Guangdong Province, China. Leveraging innovations in modular drive technology,kpowerintegrates high-performance motors, precision reducers, and multi-protocol control systems to provide efficient and customized smart drive system solutions.kpowerhas delivered professional drive system solutions to over 500 enterprise clients globally with products covering various fields such as Smart Home Systems, Automatic Electronics, Robotics, Precision Agriculture, Drones, and Industrial Automation.