Neuromorphic Control of the Serv-Arm Robot Using Spiking Neural Networks

1. Introduction

Robotic manipulators are crucial in manufacturing, inspection, assistance, and autonomous systems. Designing controllers for these platforms requires balancing accuracy, robustness, computational speed, and real-time operation, a challenge that becomes even greater when using embedded or low-cost hardware. Traditional control methods, such as proportional–integral–derivative (PID) controllers, are popular because they are simple to implement. Nevertheless, they often depend on precise mathematical models and can struggle with uncertainties, nonlinear behaviors, or actuator issues. Additionally, computing inverse kinematics in real time is computationally intensive, which limits its use on embedded processors with restricted capacity [1].

Spiking Neural Networks (SNNs) have emerged as an alternative computing paradigm inspired by the event-driven communication of biological neurons. Unlike traditional artificial neural networks, SNNs process information through sparse spike-based signals, enabling low-latency computation and potentially higher energy efficiency—characteristics that make them especially attractive for real-time robotic control on constrained hardware platforms [2,3]. These features suggest that SNNs could serve as a promising foundation for embedded manipulation tasks, particularly when combined with lightweight robotic systems.

Despite these advantages, the use of SNN-based controllers in low-cost robotic manipulators is still limited. Current research efforts tend to focus on high-performance neuromorphic hardware or simulation environments, with little attention given to assessing SNN controllers on affordable, standard hardware in practical control tasks. Additionally, the energy consumption associated with deploying SNNs compared with traditional neural architectures in embedded robotic systems remains poorly understood.

To address these gaps, this work develops and evaluates a neuromorphic controller for a low-cost Serv-Arm manipulator implemented on a Raspberry Pi–based embedded platform. The proposed system covers the entire pipeline—from synthetic dataset creation to model training, hyperparameter tuning, and real-time inference. In addition to evaluating tracking accuracy and neural dynamics, this study offers an empirical analysis of energy consumption, enabling a direct comparison between SNN- and ANN-based controllers under identical execution conditions.

The main contributions of this work are as follows:

• Developing a fully reproducible neuromorphic control framework for the Serv-Arm robotic manipulator using low-cost embedded hardware;
• Systematically optimizing SNN hyperparameters through grid search applied to a large, synthetically generated training dataset;
• Experimentally evaluating tracking accuracy, prediction error distribution, and spiking activity dynamics;
• Empirically comparing the energy consumption of SNN and ANN controllers based on continuous power measurements.

The rest of this article is organized as follows. Section 2 reviews related work on robotic manipulation and neuromorphic control. Section 3 details the methods used for data generation, model design, and system implementation. Section 4 provides the experimental evaluation and results. Section 5 discusses the findings, and Section 6 concludes the paper while indicating directions for future work.

2. Related Work

2.1. Robotic Manipulators: Kinematics, Dynamics, and Classical Control

Robotic manipulators are complex systems composed of rigid links connected by actuated joints. Their control has traditionally depended on mathematical models involving forward kinematics, inverse kinematics, and dynamics. While forward kinematics are straightforward to compute, inverse kinematics (IK) are nonlinear, often ill-conditioned, and computationally intensive, particularly when executed on embedded systems with limited resources [1]. Conventional control methods, such as proportional–integral–derivative (PID) controllers, remain popular due to their simplicity and predictable behavior. However, their effectiveness heavily relies on accurate modeling and proper gain tuning, making them vulnerable to issues such as friction, payload changes, mechanical backlash, and structural uncertainties commonly found in low-cost manipulators such as the Serv-Arm.

The computational cost of real-time IK has led to the development of alternative methods that avoid explicit geometric modeling. Among these, joint-space control architectures—in which control signals are predicted directly in the servo-angle domain—have become especially relevant for lightweight and affordable robotic platforms.

2.2. The Spiking Neural Network (SNN) Paradigm and Neuromorphic Computation

Spiking neural networks (SNNs), regarded as the third generation of neural models, operate on discrete temporal events (spikes), enabling sparse and energy-efficient computation. The most common neural model is the leaky integrate-and-fire (LIF), in which the membrane potential accumulates incoming currents until it reaches a threshold and generates a spike. Its dynamics are described by:

$${\tau }_m{\displaystyle \frac{dV\left(t\right)}{dt}}=-\left(V\left(t\right)-V_{\mathrm{rest}}\right)+RI\left(t\right)$$

(1)

where ${\tau }_m$ is the membrane time constant, $V_{\mathrm{rest}}$ is the resting potential, R is the membrane resistance, and $I\left(t\right)$ is the synaptic input current. After the potential reaches the threshold $V_{\mathrm{th}}$, a spike is emitted, and $V\left(t\right)$ is reset.

SNNs encode information through firing rates or precise spike timing [4]. Learning mechanisms such as spike-timing-dependent plasticity (STDP) provide biologically inspired adaptation rules. Neuromorphic processors such as Intel Loihi [5] and IBM TrueNorth [6] implement these neural dynamics directly in hardware, using asynchronous, event-driven computation that consumes extremely low power—an appealing feature for embedded robotic control.

2.3. Applications of SNNs in Robotic Control

Recent research has shown rapid growth in the use of SNNs for robotic control tasks. Fully spiking PID controllers have demonstrated competitive performance in multiaxis manipulators, often outperforming traditional controllers under dynamic disturbances [7]. For more complex systems, recurrent SNNs have been applied to manipulators with 6–7 degrees of freedom, learning motor coordination through spatiotemporal correlations [8]. Combined with reinforcement learning (RL), SNNs can acquire manipulation skills directly from interaction with the environment, without requiring explicit mechanical models [9]. Cerebellar-inspired SNN architectures have also shown the ability to predict and correct motion errors in real time, enhancing accuracy and reducing latency [10].

Neuromorphic hardware further expands the potential of spike-based controllers. Loihi achieves energy-delay products up to 100× lower than CPU implementations [11], while TrueNorth consumes only 65 mW during real-time inference and delivers more than 6,000 frames per watt [12]. Additional advances such as the ODIN chip achieve energy costs as low as 12.7 pJ per synaptic operation, reinforcing the feasibility of spike-based computation for embedded robotic platforms [13].

SNNs have also been applied to low-power embedded control of 4-DoF manipulators using spike-based learning [14], and to real-time manipulation tasks using event-driven sensory inputs [15]. Unsupervised SNNs can learn motor patterns solely from their temporal structure [16], while bioinspired spiking controllers demonstrate robustness to disturbances and model uncertainties [17]. Beyond manipulation, SNNs have also been explored in sensing, object detection [18], human–machine interfaces [19,20], and biological signal processing [21].

Despite these advances, most approaches rely on Cartesian-space control or implicit inverse kinematics. Few studies have investigated supervised SNNs for direct joint-space control, particularly for low-cost, limited-precision manipulators. This gap is directly addressed in the present work.

2.4. Energy Efficiency and Embedded Execution of SNNs

Energy efficiency is a key motivation for adopting SNNs in robotic control. Neuromorphic processors leverage sparse, event-driven computation to achieve substantial improvements in energy consumption. Loihi consistently outperforms GPUs and CPUs across diverse workloads, achieving up to 100× better energy-delay products [11]. TrueNorth provides highly energy-efficient inference, operating at 25–275 mW while delivering high throughput [12]. The ODIN chip offers exceptionally low energy per synaptic operation (12.7 pJ), supporting compact and versatile spike-based computation [13].

However, accurately measuring energy consumption on embedded platforms remains challenging. Osolinskyi et al. examined traditional methods for current measurement in microcontrollers, highlighting limitations of shunt resistors, multimeters, and reactive components that may introduce distortions or instability [22]. Carroll and Heiser [23] presented detailed methodologies using sense resistors and high-speed data acquisition systems to obtain accurate power profiles in embedded devices. These studies emphasize the need for rigorous and reproducible energy benchmarking protocols.

Although neuromorphic chips offer excellent energy efficiency, relatively few studies have evaluated SNN performance on low-cost, general-purpose hardware such as Raspberry Pi or Arduino. This motivates the present work, which compares SNN and ANN power consumption under identical real-time robotic control workloads executed on a fully reproducible embedded platform.

2.5. Comparison Between PID, ANN-Based Controllers, and SNN Approaches

PID controllers remain standard in robotics due to their simplicity and well-understood behavior [1]. However, their dependence on accurate models and sensitivity to nonlinearities limit their applicability in inexpensive robotic systems. Artificial neural networks (ANNs) have become powerful tools for approximating nonlinear mappings and inverse kinematics [24]. Despite their capabilities, ANNs typically require large labeled datasets, rely on dense computation, and lack inherent temporal dynamics.

SNNs overcome several of these limitations by incorporating temporal processing, stateful neural dynamics, and event-driven execution [2]. Studies have shown that SNN-based controllers can outperform PID and ANN methods under noise, sudden disturbances, or dynamic conditions [7,17]. Their intrinsic temporal memory, low-latency response, and energy efficiency make them strong candidates for embedded robotic control [11,25].

Despite progress, most existing approaches rely on Cartesian-space control or SNN-based inverse kinematics. Few studies explore supervised SNN models that perform direct joint-space control by receiving the current and desired joint configurations and predicting the subsequent motor command. The present work addresses this gap by proposing and experimentally validating an embedded, energy-efficient SNN controller for a low-cost 4-DoF robotic arm based on direct joint-space inference.

3. Materials and Methods

3.1. Description and Assembly of the Serv-Arm Robot

The Serv-Arm is an open-source robotic platform that functions as an articulated manipulator arm, as shown in Figure 1. For educational, research, and experimental use, its design is universally accessible because most of its mechanical parts are 3D printed from affordable materials such as PLA, PETG, or ABS [26]. Its architecture draws inspiration from industrial robots, featuring a serial arrangement of links and joints that provide a wide range of movement and flexibility. The structure includes a fixed base, a shoulder link, an elbow link, and an end-effector, usually a gripper. In its standard setup, the Serv-Arm has four degrees of freedom (DoF) and is operated by servo motors, as described in the original project documentation [26].

The core of the system comprises an Arduino Uno R3 microcontroller and a Raspberry Pi 4B, which are responsible for real-time control and the execution of SNN inference algorithms. The Arduino produces PWM signals for the servo motors, whereas the Raspberry Pi manages serial communication and neuromorphic model processing. Owing to its low cost and open-source design, the Serv-Arm–Arduino–Raspberry setup offers an excellent platform for experiments in robotic control and artificial intelligence [26].

The robot’s physical assembly followed open-source project guidelines, including 3D printing structural parts, integrating servo motors (3× MG90S for main joints and 1× MG90S for the gripper), and mechanically calibrating the axes to ensure accurate motion and proper alignment between commands and the actual position of the manipulator.

For control, the main motion paths were defined, covering fundamental movements such as right, left, and upward, which served as the basis for SNN training. This definition considers the Serv-Arm’s workspace and planned manipulation tasks, optimizing coverage of essential movements and ensuring representative trajectories.

3.2. Pick-and-Place Task and Motion Mapping

The main evaluation task for the system was a pick-and-place operation, in which the robot was instructed to pick up an object from a predefined initial position and move it to a predefined final position. This task demands precision in positioning and trajectory, making it an excellent benchmark for validating the neuromorphic control system. The trajectory was divided into subtasks (approach, grasp, lift, transport, release, and return), which simplified both training and performance analysis.

Unlike approaches that rely on geometric mapping algorithms to convert Cartesian coordinates into joint angles, this work trains the SNN directly to predict servo-motor angles. The model takes the current system states and desired commands as inputs and produces the normalized motor angles. Therefore, the network learns to determine the correct angles without relying on intermediate IK transformations, thereby reducing computational complexity and increasing efficiency.

3.3. Dataset Construction and Preparation for Training

The performance of the neuromorphic controller relies directly on the quality and diversity of the dataset used to train the SNN. To ensure comprehensive coverage of the workspace, a fully synthetic dataset was created using a Python-based pipeline that simulates realistic manipulator configurations, deliberately focusing on mechanically challenging regions of the Serv-Arm. A fixed random seed was applied throughout the generation process to ensure reproducibility.

Dataset generation begins by creating a pose library. Several pick-and-place and point-to-point trajectories were simulated, and the corresponding joint angles were recorded. Additional CSV files containing the operational joint limits and a reference trajectory were combined into the pose library, resulting in a diverse set of unique, physically valid configurations. Each dataset entry includes three vectors: (i) the current joint configuration, (ii) a randomly chosen target configuration, and (iii) the next incremental step to be taken. To mimic real-world imprecision, Gaussian noise was independently added to each joint angle.

Motor 2 exhibited reduced noise variance because of its mechanical design. The shoulder joint handles vertical movement and bears most of the arm’s load, making it especially sensitive to noise. Minor disturbances in this joint can cause significantly larger deviations in the end-effector’s path, particularly in near-vertical positions. Lowering its injected noise helps produce more realistic samples and prevents implausible posture shifts. After noise was added, all the angles were clipped to stay within their physical limits.

To clarify the distribution, Figure 2 and Figure 3 show histograms of the current, target, and next-step angles for all four motors. The multimodal patterns across joints highlight the focus on difficult workspace areas and support an intense training distribution.

A statistical summary of the dataset is provided in Table 1, which shows the mean and standard deviation for each motor across all three vector types. These statistics confirm that the dataset covers the entire operational workspace while maintaining physically consistent transitions.

The next-step vector for each sample is calculated via a proportional update rule, where each joint moves a small step toward the target configuration. The step size depends on the magnitude of the joint error but is capped by a maximum limit specific to each joint. Motor 2 again has a more restrictive cap to avoid sudden vertical movements that could destabilize the manipulator or cause unrealistic configurations.

To ensure that the SNN observes enough examples in the most error-prone regions, a curriculum-inspired balancing strategy was used. Approximately 10% of the samples focus on extreme values of motor 2, 5% represent workspace boundary cases, and additional subsets cover mid-range elevation movements, microadjustments, and edge interactions of motors 1 and 3. This ensures that the network encounters diverse scenarios and develops stable generalization behavior.

Finally, all values were normalized to the [0, 1] range and divided into 80% for training, 10% for validation, and 10% for testing [27]. For clarity and reproducibility, Algorithm 1 summarizes the pipeline used to generate the synthetic dataset.

Algorithm 1:Synthetic Dataset Generation (Simplified)

1: Load pose library $\mathcal{P}$ from simulated trajectories and CSV files. 2: Determine joint limits ${\theta }_i^{min}$ and ${\theta }_i^{max}$. 3: for$k=1$ to $500,000$ do 4:     Sample pair $({\Theta }_t,{\Theta }^{goal})$ following balancing rules. 5:     Apply Gaussian noise: $\tilde{\Theta }=\Theta +\mathcal{N}(0,\sigma )$). 6:     Clip angles to joint limits. 7:     Compute next-step ${\Theta }_{t+1}$ with proportional update and step caps. 8:     Store $({\Theta }_t,{\Theta }^{goal},{\Theta }_{t+1})$. 9: end for 10: Normalize dataset to $[0,1]$. 11: Partition into train/validation/test.

3.4. Integrated System Architecture

The complete architecture of the proposed neuromorphic control system is shown in Figure 4 and consists of five main stages. In the Data Acquisition stage, the Arduino microcontroller and Serv-Arm manipulator record joint movements and operational limits, stored in CSV files to ensure the SNN operates within physical constraints. The Preprocessing stage normalizes all collected data and performs hyperparameter optimization via a grid search, varying hidden layer size, learning rate, and membrane decay factor. The best configuration is saved in a JSON file.

During the Learning stage, the SNN is trained using Leaky Integrate-and-Fire (LIF) neurons, where inputs are encoded as spike trains representing current and target joint configurations. Synaptic weights are optimized using surrogate gradient descent, and the trained model is exported as a .pth file.

The Decoding stage converts spike-based outputs into continuous motor commands using spike rate averaging or first-spike latency decoding. These decoded values are denormalized to actual motor ranges (e.g., $0^{\circ }$–${180}^{\circ }$). Finally, in the Motion Execution stage, the Raspberry Pi sends the denormalized commands to the Arduino via serial communication, where PWM signals drive the servo motors to execute tasks such as pick-and-place.

3.5. Energy Measurement

Assessing the energy consumption of neural controllers on embedded hardware is crucial for determining their suitability for real-time robotic tasks, especially on affordable platforms such as the Raspberry Pi. One of the main reasons for using Spiking Neural Networks (SNNs) is their potential energy efficiency compared with traditional artificial neural networks (ANNs); therefore, a specific and reproducible measurement process was included in the experimental setup. The goal was to measure, under the same operating conditions, the electrical demand of both controllers during the pick-and-place task.

To obtain accurate current measurements without altering the internal circuitry of the Raspberry Pi 4B, an external Hall-effect sensor (ACS712-20A) was connected in series with the power supply line. This method follows established low-cost measurement practices, where external current-sensing modules or shunt-based techniques are commonly used to capture real-time power traces in embedded systems. The ACS712 converts the load current into an analog voltage proportional to the instantaneous current, which an Arduino Uno R3 samples through its 10-bit analog-to-digital converter (ADC). The Arduino performs basic filtering and sends the processed values to the Raspberry Pi, where current, power, and energy logs are synchronized with the robot’s motion data.

During operation, each batch of 150 ADC readings is averaged to reduce high-frequency noise, a recommended technique when using low-cost Hall-effect sensors. The instantaneous current $I\left(t\right)$ is estimated via the nominal sensitivity of the ACS712-20A (100 mV/A), and readings below 0.1 A are suppressed through a deadband filter to reduce offset noise. The instantaneous electrical power is then calculated assuming a constant 5 V supply according to:

$$P\left(t\right)=V·I\left(t\right)$$

(2)

where $P\left(t\right)$ denotes the instantaneous power, V is the supply voltage (fixed at 5 V), and $I\left(t\right)$ is the measured current. The mean power over a trial is obtained by:

$$\overline{P}={\displaystyle \frac{1}{K}}\sum _{k=1}^{K}P\left(t_k\right)$$

(3)

and the total energy consumed during each pick-and-place operation is given by:

$$E=\overline{P}·t$$

(4)

where E is the total energy (in Joules) and t is the duration of the manipulation routine.

This methodology aligns with established neuromorphic hardware evaluation practices, where energy consumption is calculated by integrating or averaging power over the execution interval [11,13]. To ensure reproducibility, all experiments were repeated multiple times for both controllers. Repetition reduces sensor noise, ADC quantization effects, and runtime variability on the Raspberry Pi 4B—factors known to affect low-cost embedded energy measurements [22]. All trials were conducted under identical electrical, mechanical, and software conditions to guarantee consistent comparisons.

A high-level overview of the acquisition and processing pipeline is given in Algorithm 2, which describes the entire process from sensor calibration to real-time sampling and final task energy calculation.

Algorithm 2:Energy Measurement Procedure Using the ACS712-20A Sensor

1: Initialization: 2: Set sensor parameters ($V_{CC}=5$ V; ADC resolution 1023; sensitivity $S=100$ mV/A). 3: Initialize serial communication at 9600 baud. 4: Offset Calibration (no load): 5: Collect $N=500$ ADC samples. 6: Compute zero-current offset $V_{\mathrm{offset}}$. 7: Real-Time Sampling: 8: for each sampling interval do 9:     Read 150 ADC samples and compute moving average $V_{\mathrm{out}}$. 10:     Estimate current $I\left(t\right)$ using $V_{\mathrm{offset}}$ and sensitivity S. 11:     Apply deadband: if $\left|I\right(t\left)\right|<0.1$ A, set $I\left(t\right)=0$. 12:     Compute power $P\left(t\right)=5.0·\left|I\right(t\left)\right|$. 13:     Send $\left(I\right(t),P(t\left)\right)$ to the Raspberry Pi. 14: end for 15: Energy Computation (Raspberry Pi): 16: Compute mean power $\overline{P}$. 17: Measure task duration t. 18: Compute energy $E=\overline{P}·t$.

3.6. Spiking Neural Network (SNN) Architecture and Optimization

The spiking neural network (SNN) developed in this work was designed to process trajectory data and generate control commands for the Serv-Arm robot. Its architecture follows a feedforward model with input, hidden, and output layers, where neurons utilize the leaky integrate-and-fire (LIF) model with parameters optimized for the task.

The input layer receives encoded data that represent the robot’s current position and, optionally, the target position. These data are transformed into spike trains via temporal encoding methods such as latency or rate coding, enabling the network to capture the spatiotemporal dynamics of movements. After training, the SNN operates in an event-driven manner: neurons integrate incoming signals and fire spikes, transmitting activity across layers. The output layer produces spike trains that are decoded into continuous values representing the adjustment commands for the Serv-Arm servo motors.

The optimal number of neurons and other hyperparameters were selected via a grid search, and variables such as the hidden layer size, learning rate, and membrane potential decay factor ($\beta$) were evaluated. Each setup was trained and evaluated on the basis of validation loss and mean absolute error (MAE).

4. Results

4.1. Contributions and Approach Differentials

Several previous studies have examined the use of machine learning and neuromorphic control techniques for robotic manipulators, focusing on energy efficiency and generalization to embedded systems. Classical controllers, such as PID and adaptive types, continue to be the industry standard for manipulator control. However, these methods have well-known limitations, especially in situations with dynamic uncertainties and incomplete system models, where slight changes in load or friction can significantly reduce performance [1].

Recent research has introduced artificial neural networks (ANNs) to approximate nonlinear control functions in robotics, achieving greater adaptability but at a high computational cost. Other studies expand on this by emphasizing the potential of Spiking Neural Networks (SNNs) as natural successors to ANNs, given their event-driven design and low energy consumption. These works demonstrate that SNNs can produce results comparable to those of traditional methods in trajectory-tracking tasks, although most approaches remain limited to simulations or proprietary neuromorphic hardware platforms, such as Intel Loihi or SpiNNaker, which limits reproducibility and real-world application [3,14,28].

In [15], a neuromorphic control architecture based on SNNs was proposed for a four-degree-of-freedom robotic arm, showing superior energy efficiency and good temporal stability. However, the study concentrates on computational performance analysis rather than physical validation on accessible robots, and relies on specialized hardware for real-time execution. Other works explore the training of spiking networks but depend on limited datasets and lack a systematic methodology for sample generation and balancing [14].

This work differs by proposing a neuromorphic control system built entirely from low-cost, widely available hardware, combining a Raspberry Pi 4B, an Arduino Uno R3, and a Serv-Arm manipulator, without requiring dedicated neuromorphic platforms. Additionally, the synthetic data generation method developed here produces a dataset with over 500,000 balanced samples spanning the robot’s entire workspace, enabling the SNN to learn spatiotemporal relationships in a broader and more robust manner [26,27].

Another distinctive feature is systematic hyperparameter optimization via grid search, which helps identify the best configurations for the architecture, learning rate, and membrane decay factor. This step, absent from many prior studies, enhances transparency and scientific reproducibility. Finally, while previous work has often been limited to simulation analysis, this paper experimentally verifies the approach on a complete pick-and-place task, demonstrating the practical feasibility of a neuromorphic controller operating in real time with accuracy comparable to that of traditional techniques [3,28].

Therefore, this study advances the field by demonstrating that satisfactory performance and computational efficiency can be achieved in a fully reproducible neuromorphic robotic system without relying on proprietary hardware. The combination of synthetic data generation, hyperparameter optimization, and physical execution of the model positions this work as an accessible and effective alternative for intelligent control of robotic manipulators [3,14,15].

4.2. SNN Training and Results

Training the spiking neural network (SNN) was preceded by a hyperparameter optimization stage that used a grid search with 54 different configurations. The variables examined included the hidden layer size, learning rate (LR), and membrane potential decay factor ($\beta$). Model performance was assessed via validation loss and the mean absolute error (MAE), with early stopping employed to prevent overfitting. Table 2 shows the best results achieved.

The final chosen model features a 128-neuron hidden layer, a learning rate of $1\times {10}^{-3}$, and $\beta =0.7$, achieving an MAE of $11.{06}^{\circ }$ and a validation loss of $0.0291$. The Adam optimizer and a weighted mean squared error (MSE) loss were used for training to address dataset imbalance. Synaptic weight updates were performed via surrogate gradient descent, a technique that addresses the nondifferentiability of the neuron firing function.

Model regularization employs early stopping, halting training after 15 epochs without improvement in the validation MAE. To conserve computational resources, the model was compiled, and the batch size was dynamically adjusted based on GPU capacity. Table 3 summarizes the implementation specifications for both training and real-time execution of the SNN model on the robotic platform.

4.3. Performance Analysis

System performance was assessed by examining both prediction behavior and internal SNN activity. The evolution of the membrane potential in the output neurons is displayed in Figure 5, enabling analysis of the firing dynamics and the stability of the network’s responses throughout the temporal encoding window.

The variation among the four output neurons shows that each responds differently to the input pattern, which corresponds to the mapping from the predicted angles to the robot’s different servo motors. Membrane potential analysis verified network stability during task execution and motor command consistency, demonstrating that the SNN maintains dynamics consistent with the manipulator’s control requirements.

4.4. Learning Curves

During SNN training, learning dynamics were tracked through the training and validation loss curves (Figure 6). Both curves show a steady decrease during the initial epochs, indicating stable optimization and effective convergence of the surrogate-gradient learning process. The close match between training and validation losses throughout the entire training process suggests strong generalization and shows that the model did not overfit the training data. After approximately 60 epochs, minor fluctuations in the validation loss appear, as expected, due to the stochastic nature of the synthetic dataset and the noise added during sample creation. These oscillations remain small and stable, not affecting the overall convergence trend, confirming that the chosen hyperparameters (hidden layer with 128 neurons, learning rate of ${10}^{-3}$, and decay factor $\beta =0.7$) produce a well-behaved model with consistent learning stability.

4.5. Per-Joint Quantitative Evaluation

Figure 7 shows the distribution of the mean absolute error (MAE) per joint on the test set. The base and elbow joints have low median errors, but some outliers reach higher values, indicating isolated cases with more complex trajectories. The shoulder joint shows the best dispersion, confirming that vertical arm movement is the most challenging movement for the network. The gripper joint has the lowest variability and the smallest absolute errors, suggesting that the SNN controls this actuator with high consistency.

Although some outliers with high absolute errors are observed, they occur at boundary configurations of the robot’s workspace where kinematic nonlinearities are more significant. In the central operating areas, the network shows low and consistent errors across all joints. This indicates that the SNN generalizes well under normal conditions, whereas extreme configurations lead to larger deviations due to the mechanical and geometric constraints of the Serv-Arm.

4.6. Energy Consumption Evaluation

The energy efficiency of both controllers was evaluated during the actual execution of the pick-and-place routine using a Raspberry Pi 4B as the inference platform. Unlike many previous studies that rely on smart sockets or software estimators, this work uses a dedicated measurement system based on the ACS712-20A Hall-effect current sensor connected to an Arduino Uno R3, enabling continuous recording of instantaneous voltage, current, and electrical power throughout each experiment.

ACS712 measures the current magnetically, providing galvanic isolation and stable readings even during rapid power fluctuations. To ensure reproducibility, the sensor was calibrated with a known resistive load and offset correction. During each run, the Arduino streamed the formatted measurement packets containing Vout, the estimated current, and the instantaneous power over the serial interface to a Python script, which recorded all samples in CSV format for statistical analysis.

Three independent trials were conducted for each controller (SNN and ANN) under precisely identical electrical, mechanical, and software conditions. Each trial involved booting the inference platform, launching the respective controller, and recording power consumption until the pick-and-place task was finished. All measurements were then processed to calculate the average power for each run.

Figure 8 displays the distribution of average power consumption over the three repetitions for each model. The ANN baseline showed an average power consumption of approximately 4.36 W, with minimal variation across trials. In contrast, the SNN used approximately 4.42 W on average. Although the difference is slight—just a few tens of milliwatts—it remains consistent across all runs.

This behavior aligns with previous studies assessing SNN performance on traditional von Neumann hardware [22,23]. Unlike dense ANNs, which perform a single forward pass per control cycle, the SNN in this work uses temporal unrolling over 25 internal simulation steps to mimic membrane dynamics and spike-based information flow. This increases the number of arithmetic operations and memory accesses per prediction, resulting in a slightly higher CPU workload and, consequently, greater power consumption.

Notably, this overhead is not inherent to SNNs themselves but results from simulating spike dynamics on hardware primarily designed for synchronous computation. When used on neuromorphic processors such as Intel Loihi or ODIN, SNNs take advantage of sparse, event-driven communication and localized memory access, leading to energy reductions of one to three orders of magnitude compared with CPU/GPU execution [11,13]. Therefore, the results presented here serve as a software-based execution baseline rather than indicating the actual energy efficiency potential of the neuromorphic model.

Although the Raspberry Pi 4B is not optimized for spike-based computation, the measurements obtained here are still valuable for two reasons. First, they quantify the computational overhead of running an SNN controller on a widely accessible embedded platform. Second, they provide a reproducible reference point for future evaluations of dedicated neuromorphic hardware, where significant energy savings are expected due to event-driven computation and massively parallel spike processing.

Overall, although the ANN used slightly less energy during CPU execution, the differences are minor and due to the extra temporal simulation needed by the SNN. These results align with expectations for software-based SNN inference on traditional processors and emphasize the need to deploy optimized neuromorphic architectures to fully harness spike-based energy savings.

4.7. Joint-Level Error Distribution

System performance was assessed on the basis of trajectory accuracy and final positioning. To gain a clearer understanding of the model’s behavior, the distribution of prediction errors across all joints was examined. Figure 9 shows the histogram of errors calculated from 10,000 samples in the test set.

The error distribution across 10,000 test samples shows that all joints have predictions concentrated near zero, indicating that the SNN learns a stable and unbiased mapping from inputs to motor commands. The Base (M1) and Elbow (M3) joints exhibit narrow distributions, confirming the accuracy of mid-range lateral movement modeling. The Shoulder joint (M2) presents the greatest variability, which is consistent with its mechanical role in vertical elevation, where small angular variations result in larger end-effector deviations due to nonlinear kinematics. The Gripper (M4) displays the tightest error distribution, reflecting its limited range of motion and simpler kinematic structure. Overall, these results confirm the SNN’s ability to generalize across most of the manipulator’s workspace, with larger deviations occurring only in mechanically challenging configurations.

5. Discussion

The results of this study show that a neuromorphic controller based on spiking neural networks (SNNs) can provide stable, consistent joint-angle predictions for a low-cost robotic manipulator. The optimized model reached a mean absolute error (MAE) of approximately 11°. While this accuracy is not on par with that of high-precision industrial manipulators, it aligns well with the mechanical limits of the service arm platform, the embedded hardware used, and the open-loop control strategy in this work.

A jointwise analysis shows a clear mechanical link between the model’s prediction errors and the robot’s structure. The shoulder joint (M2), which controls vertical movement, displayed the highest variability. This is expected: minor angular deviations at this joint lead to larger displacements at the end effector owing to geometric nonlinearities and lever–arm effects. Conversely, the gripper joint (M4) showed the least variation, reflecting its limited mobility and minimal impact on the overall kinematics. These results suggest that part of the error comes not from learning limitations but from the robot’s mechanical constraints.

SNNs provide structural benefits over traditional artificial neural networks (ANNs). Although ANN baselines may achieve higher numerical accuracy, they often rely on dense activation patterns and continuous computations, which can increase computational costs on embedded platforms. SNNs, however, leverage temporal dynamics, sparse event-driven communication, and biologically inspired processing methods that are theoretically better suited to low-power execution. The use of Gaussian noise and dataset balancing during synthetic sample creation may have further enhanced the robustness of the SNN controller.

Importantly, the SNN trained only on synthetic data was successfully generalized to a real robotic system. Despite differences between the simulation and physical conditions—such as servo backlash, asymmetric friction, mechanical tolerances, and UART communication delays—the model successfully executed the whole pick-and-place routine. This domain-transfer ability shows that the synthetic data generation method was sufficiently expressive to capture the key kinematic relationships of the Serv-Arm and that the neuromorphic controller is robust to real-world noise and imperfections.

An energy consumption analysis provides further insight into the practical performance of the neuromorphic controller. Although SNNs are generally linked to energy efficiency, this trait is fully realized only on neuromorphic processors that enable sparse, event-driven computation. On a traditional von Neumann processor such as the Raspberry Pi 4B, the SNN must be simulated via temporal unrolling—25 internal simulation steps per inference—resulting in increased arithmetic operations and memory access. As a result, the SNN uses slightly more power ($\approx 4.42\mathrm{W}$) than the ANN baseline ($\approx 4.36\mathrm{W}$). This slight but consistent difference aligns with expectations for software-based SNN execution. This reflects not the intrinsic efficiency of the spiking model but the cost of simulating its dynamics on general-purpose hardware.

Despite these limitations, the results demonstrate the feasibility of deploying SNN-based controllers on readily available embedded platforms and highlight the need for future work to integrate the system with dedicated neuromorphic processors such as Intel Loihi or ODIN. Compared with CPU execution, such hardware can leverage sparse spike-based communication, local memory, and asynchronous processing, enabling reductions of one to three orders of magnitude in energy consumption.

In summary, the proposed neuromorphic controller shows that biologically inspired models can be a practical, robust, and computationally efficient option for low-cost robotic manipulators. The approach eliminates the need for complex analytical models or high-end hardware, offers reproducible learning dynamics, and sets the stage for future applications on neuromorphic architectures where the full benefits of spike-based computation can be utilized.

6. Conclusions

This work introduces a complete neuromorphic control system for a four-degree-of-freedom robotic arm, implemented via a spiking neural network (SNN) and fully deployed on affordable, widely available hardware. By integrating large-scale synthetic data generation, systematic hyperparameter tuning, and physical testing on the Serv-Arm platform, the proposed controller achieved stable, consistent joint-angle predictions across most of the robot’s workspace.

The optimized SNN, which includes a 128-neuron hidden layer, a learning rate of $1\times {10}^{-3}$, and a membrane decay factor $\beta =0.7$, achieved an average prediction error of approximately ${11}^{\circ }$. Jointwise evaluation revealed that most errors stem from the manipulator’s mechanical properties, especially at the shoulder joint (M2), where minor angular deviations amplify end-effector motion owing to geometric nonlinearities. These findings suggest that the SNN learned the robot’s underlying kinematic structure even when trained solely on synthetic samples.

A key contribution of this study is that neuromorphic controllers can operate reliably on embedded platforms such as the Raspberry Pi 4B and Arduino Uno R3 without specialized neuromorphic hardware. The energy consumption analysis also revealed that when run as software simulations on a standard CPU, the SNN uses slightly more power than the ANN baseline does. This slight increase is fully accounted for by the temporal unrolling required to simulate spike-based dynamics and does not reflect the inherent efficiency of neuromorphic computation. Instead, these results provide a practical performance baseline for future deployment on dedicated neuromorphic processors, where sparse, event-driven computations can yield significant energy savings.

Future work will focus on increasing task complexity, exploring deeper or multilayer SNN architectures, adopting biologically inspired or population-based encoding schemes, and integrating closed-loop control to reduce accumulated drift in mechanically challenging regions of the workspace. Additionally, evaluating the approach on an industrial-grade robotic manipulator will enable testing under more demanding precision and robustness requirements.

Overall, the findings confirm the viability of neuromorphic control for low-cost robotic manipulators and emphasize the potential of SNNs as a biologically inspired and embedded-friendly alternative to traditional ANN- or PID-based controllers. The approach presented here, from synthetic dataset creation to real-world testing, offers a reproducible and accessible framework for advancing neuromorphic robotics research.