Developing Different Test Conditions to Verify the Robustness and Versatility of Robotic Arms Controlled by Evolutionary Algorithms

Abstract

In this paper, different test cases where robotic arms are tested will be presented. A robotic arm is tested for the gravity effects that can be observed on it. The other robotic arm is tested for how much precision it has by using it to learn to write. The other robotic arm is tested on how well it can function as a solar tracker and how precisely it can function as an energy harvester. On the basis of these tests, the robotic arm’s mechanical structure, electronics, and software are put to the test. The software is based on evolutionary software that implements genetic algorithms. The entire command system is also ported to FPGAs (to hardware) to increase speed and response time.

1. Introduction

Different test conditions for the robotic arms will be presented. One test condition is the gravity effect; the other is the robot arm, which can learn to write; and the third is the robotic arm as a solar tracker. All robotic arms are controlled by genetic algorithms. The solar tracker was also implemented in FPGAs to prove that in any condition, the genetic-algorithm-controlled robotic arm behaves flawlessly.

Evolutionary algorithms, or genetic algorithms, are used in this paper because they use methods inspired by biology, such as selection, reproduction, crossover, or mutation. The fitness function determines the quality of the solution of the optimization methods. The evolution of the population will be done after repeatedly using the previously mentioned methods inspired by biology.

The novel contribution of this paper is to test genetic algorithms driven by robotic arms in different conditions in order to determine their robustness and versatility. The three tests are: testing gravity effects on robotic arms; testing precision by trashing them to write; and using them as solar trackers.

The paper will be presented in a circular form by presenting Problem Formulation, Problem Solving, Results, Discussions, and Conclusions for all three tested aspects of the robotic arms: gravity effects, learning to write, and solar tracker.

1.1. Gravity Effects

Robotic arms, intended to copy the design and capability of biological limbs [1], definitely stand out for their flexibility and adaptability [2]. One of the essential difficulties in controlling such robotic arms is the impact of gravity [3]. The first part of this article presents an original way to deal with the impacts of gravity on robotic arms [4]. The aim is to show the versatility of these arms under gravity conditions [5], making them functional for a wide range of uses [6].

1.2. Learning to Write

The industry becomes more and more robotized with each passing day. All human operators are replaced by robots day by day. One of the most used robots in the industry is the robotic arm [7]. The robotic arm actually mimics the human arm, but it can be scaled to perform any desired task [8]. The robotic arm can be much bigger than the human arm and can have the strength to lift heavy objects, which a human arm cannot carry [9]. All this can be done by the robot faster, continuously, without brakes, and more precisely. The robotic arm is not only used to manipulate objects but also to make really precise operations.

One really precise operation is drawing or writing, which can be really well done with a robotic arm.

The robotic arm has the precision to mimic human handwriting [10].

Why do this? The robots are all done to mimic humans as much as possible [11]. The robot creators always aim for perfection in the human being [12]. They try to create a robot as close as possible to men [13]. This is why writing or drawing with a robotic arm actually makes sense [14]. A robot could also print text, but that is machine-like, not human-like [15]. To be as human as possible, the writing or drawing must be done exactly as a human would do it, but all of it will be done by a robot or a robotic arm in our case.

1.3. Solar Tracker

Energy generation is a big need in today’s consumer world [16]; we have a greater need for energy than ever [17]. We do not need electricity just for light in our room [18], but for many electrical devices, handheld devices, mobile phones, tables, smart watches, and all the IoT (Internet of Things) equipment present in today’s world [19]. Not to talk about the large energy demand of electric cars [20], which will inevitably be the major vehicles on the road in the near future and maybe the only vehicles on the road in the not too far future [21].

To withstand the energy demand, we need to generate it [22]. What better way to achieve this than by doing it with microgrids [23]. Every home should generate the needed energy for itself. For this, the best and maybe the greenest way of generating energy is by mounting solar panels [24].

Contemporary green energy solutions include innovative alternatives to traditional renewable sources [25]. Solar panel installations saw a 41% increase from 2000 to 2015 [26]. It is less known that the payback period is approximately 2.5 years in northern Europe and potentially less than 1.5 years in southern Europe. Given the typical 20-year lifespan of a photovoltaic system, it is capable of producing 20 times the energy required for its manufacture. It is projected that within 5 years, the cost of energy from photovoltaic panels will undercut that from gas or coal combustion, and in 20 years, it will become the most economical energy source.

The performance of solar cells has consistently improved; the peak efficiency for a single crystalline silicon cell is 25.6%, and 20.8% for multicrystalline cells. The efficiency rates are 21% for CdTe (Cadmium Tellurium) films and 20.5% for CIGS (CuInGaSe or Copper Indium Gallium Selenide) cells [27]. By employing a mechanism that aligns solar panels with the sun, their efficiency can be enhanced by up to 30% over fixed panels. As solar panel efficiency improves, fewer panels are needed, thus decreasing both cost and space requirements [28].

Developing such a robotic system is challenging, as it must function reliably in all weather conditions outdoors [29]. This project spans multiple disciplines, including electronics, mechanics, mechatronics, automation, and software [30], necessitating precise coordination and complex mathematical calculations related to the sun’s position and the required motor movements [31,32].

The system’s innovation lies in its modular construction [33], its universal and adaptable methodology [34], and its simplicity, affordability, and scalability [35].

2. Problem Formulation

2.1. Gravity Effects

Robotic arms are intended to duplicate the qualities and abilities of normal limbs [36], frequently using biomimetic standards to improve versatility and execution [37].

Gravity altogether influences the movement of robotic arms [38], which requires different systems to verify its effects [39], including stabilizers [40], force sensors, and control calculations.

2.2. Learning to Write

The task is quite clear: to teach a robotic arm to write or draw.

The Lynxmotion AL5B robotic arm was chosen because it was the only robotic arm available in our laboratory, but it was also a well-known robot by the author.

The Lynxmotioin AL5B robotic arm uses different kinds of Hitec servomotors. The different Hitec servomotors differ only in the torque that they can make, based on the the fact that some models are bigger or smaller and some models can have metric gears instead of plastic ones. The metallic gear teeth are harder to brake than the plastic ones. In positions like the base or shoulder, where more torque is needed, usually bigger Hitec servos with metallic gears are used. The robotic arm is equipped with HS-475HB at the base, HS-755HB at the shoulder, HS-645MG at the elbow, HS-475HB at the wrist, and HS-422 at the gripper. There is no wrist rotation servomotor installed on this robot. This robot has four degrees of freedom (DOF), base rotation, shoulder front-back, elbow up-down, and wrist up-down, and it does not uses any sensors.

The initial task was to teach the robotic arm to write some letters, and then the robotic arm should memorize the path of movement so that it can reproduce the writing itself.

The easiest way to do this is to create an application that can save in text files the positions of the motors placed in the joints of the robotic arm. After that, another application or the same application was created that could read the text files with the positions of the robotic arm. In this way, after the robotic arm is taught to write, it can actually reproduce the taught writing of the letters.

2.3. Solar Tracker

The aim of this document is to develop robotic machinery that identifies the sun’s position and accordingly adjusts solar panels (Figure 1), building upon the author’s prior research interests.

The solar tracker robot uses two SG90 microservos, has two degrees of freedom (DOF), up-down and left-right, and uses four photoresistors, or LDRs.

The primary objective is to develop a working robotic prototype capable of tracking the sun and managing the rotation of a solar panel farm to enhance its efficiency. This robot will be designed to adapt to the local community’s requirements and will be incorporated into the SmartCity framework, providing real-time information on the best orientation within the serviced region.

The system consists of three main parts: the mechanical one, for precise positioning, executed with motors and limiters of movement, a control part with development board, software and the sensor system.

As can be seen in the middle, there are the photoresistors that are used to capture light from the sun. Separated walls are used to know the direction from which the light of the sun is captured. This system is made according to the four quadrants of the Cartesian coordinate system. This coordinate system can be used to rotate the solar tracker robot in both horizontal and vertical directions according to the x0y axes.

The main goal of this paper is to present how to create a microcontroller architecture on an FPGA (Field Programmable Gate Array), which can be used to control a solar tracker robot.

Additionally, the project aims to develop a robotic prototype capable of tracking the sun to manage and adjust the orientation of either a single solar panel or an entire solar panel farm, thus improving its operational efficiency. This robot should be flexible enough to meet the specific demands of the local power network. In addition, the system should be compatible with the SmartCity infrastructure, providing real-time data collection that will be archived in the cloud for subsequent analysis to determine the best alignment procedures.

The system will consist of three main parts: mechanical, for precise positioning using motors and limiters for movement; hardware with the FPGA board; and software with the sensor system.

The reason for using an FPGA is to be able to upgrade the microcontroller architecture just by reprogramming, so there is no need to physically replace the microcontroller. By upscaling the system, there will surely be a need to replace the microcontroller with a more powerful one with more ports or a higher operating frequency.

3. Problem Solving

3.1. The Proposed Genetic Algorithm

Figure 2 displays a simplified diagram of the genetic algorithm, which is applicable to a robotic arm.

The genetic algorithm employs terminology from biological genetics, though the meanings of these terms can slightly differ when adapted to software contexts.

Command strings or character arrays, analogous to deoxyribonucleic acids (DNAs) or gene arrays, are transmitted to each motor or joint of the robotic arm to facilitate movement. For instance, a gene might be represented as “9;120”, indicating the movement angles at the robot’s joints, with $9^{\circ }$ and ${120}^{\circ }$, respectively. These gene arrays are essentially command strings derived from a character array tailored for the robot.

In this context, a gene is a single number like “9”. This number, “9”, represents the phenotype, corresponding to the natural movement required by one of the robot’s joints to rotate $9^{\circ }$. Previously, the genotype was defined by the ASCII value of the character “9”, which is 57. Each gene is generated by creating random ASCII numbers that are converted into characters, forming the phenotype or the motor command string for the robotic arm.

All DNAs, gene arrays, or command strings for the robotic arm (character arrays) serve as the parents and are placed in a mating pool to engage in mating or crossover to generate an offspring. Crossover is performed by merging one half of a parent’s command string with one half of another parent’s command string, resulting in the creation of an offspring through this method.

In genetics, mutation denotes the modification of a random gene. This phenomenon also occurs in biological organisms, preventing excessive similarity among them. Consequently, no two individuals are exactly alike; they inherit traits from their parents but also exhibit unique differences. For example, it is possible for children with brown hair to be born to blonde parents. Mutations are crucial in situations where a system cannot evolve due to unchanging genes. At times, within the mating pool, the parents may be too similar, and only a mutation can advance the system from a stagnant state or an evolutionary impasse. In programming, a mutation involves replacing a random character with another at an arbitrary point in the gene array. This is achieved by generating a random ASCII value, converting it to the corresponding character, and inserting it into the gene array at a random location.

Essential variables for the genetic algorithm include: totalPopulation (e.g., 150, representing the number of parents (robotic arm command strings) that will interbreed), target (the desired robotic arm command string), population (the created array of robotic arm command characters (gene array)), and match (the array of calculated fitness scores).

The initial step in this algorithm is the creation of the command character arrays (genes) for the robotic arm, termed population initialization.

The next phase is selection, where the fitness scores (or matching scores) are evaluated to determine which robotic arm command most closely aligns with the target. This establishes a mating pool. In the mating pool, robotic arm command strings that will be combined to generate a new offspring (robotic arm command strings) are selected. Those with higher fitness or matching scores are more likely to be included in the mating pool, enhancing their chances of mating and producing an offspring.

The third stage is reproduction, which involves the actual crossover process. Two arbitrary robot command strings are selected from the mating pool for crossover, which is executed by merging the first half of one robot command string with the second half of another robot command string. Mutation plays an essential role in the genetic algorithm, mirroring its importance in biological genetics. When two nearly identical robot command strings (the parents) are combined, it becomes impossible to achieve the desired robot command string (the child) that ensures optimal motor positioning for precise robot control. Mutation is the sole method to achieve the desired command string under these circumstances. Mutation involves modifying the robot command string by inserting a random character and value, signifying a genetic mutation (i.e., a change in the character of the robot’s command). This is analogous to genetic variations in biology, such as a child inheriting blue eyes from parents with green and brown eyes. The newly formed child then replaces the existing population, entering the mating pool to become a parent and subsequently crossing with another to produce an offspring. This crossing process continues until the desired robot command string is achieved. Each child initiates a new generation, and the number of generations needed to reach the target command string depends on its complexity. Each generation starts with the creation of a target command string for one motor, followed by another, and after each generation, the robot’s command string is sent to the robotic arm to move it according to the command string. Following each generation, the system regenerates the mating pool from the new generation.

3.2. Gravity Effects

The position function for the moving object is shown on Equations (1) and (2).

$$\mathbf{p}\left(t\right)=x\left(t\right)\mathbf{i}+y\left(t\right)\mathbf{j}+z\left(t\right)\mathbf{k}$$

(1)

$$\mathbf{p}\left(t\right)=rcos\left(t\right)\mathbf{i}+rsin\left(t\right)\mathbf{j}+st\mathbf{k}$$

(2)

The vector of velocity of the moving object at time t is shown on Equations (3) and (4).

$$\mathbf{v}\left(t\right)={\mathbf{p}}^{\prime }\left(t\right)=x^{\prime }\left(t\right)\mathbf{i}+y^{\prime }\left(t\right)\mathbf{j}+z^{\prime }\left(t\right)\mathbf{k}$$

(3)

$$\mathbf{v}\left(t\right)=-rsin\left(t\right)\mathbf{i}+rcos\left(t\right)\mathbf{j}+s\mathbf{k}$$

(4)

The vector of acceleration of the moving object at time t is shown on Equations (5) and (6).

$$\mathbf{a}\left(t\right)={\mathbf{v}}^{\prime }\left(t\right)=x^{″}\left(t\right)\mathbf{i}+y^{″}\left(t\right)\mathbf{j}+z^{″}\left(t\right)\mathbf{k}$$

(5)

$$\mathbf{a}\left(t\right)=-rcos\left(t\right)\mathbf{i}-rsin\left(t\right)\mathbf{j}$$

(6)

The the moving object at time t is shown on Equations (7) and (8).

$$v\left(t\right)=\left|\mathbf{v}\left(t\right)\right|=\sqrt{{\left(x^{\prime }\left(t\right)\right)}^2\mathbf{i}+{\left(y^{\prime }\left(t\right)\right)}^2\mathbf{j}+{\left(z^{\prime }\left(t\right)\right)}^2\mathbf{k}}$$

(7)

$$v\left(t\right)=\sqrt{{(-rsin\left(t\right))}^2+{(rcos\left(t\right))}^2+s^2}$$

(8)

In Figure 3, it is presented the 3D model of the robotic arm used. This robotic arm is used for experiments to test the effects of gravity on its movements. The robotic arm has colored markers at each joint to know the coordinates (the position) of each joint in the space. The robotic arm is controlled with a genetic algorithm using evolutionary position computation with the help of stereo imagery.

In Figure 4, a real image of the robotic arm used is presented. Markers used to detect its joints are visible. They were created by using bottle caps with different colors (they would have been ideal colored spheres) in order to see a portion of the marker, even if the robotic arm rotates and is perpendicular to the plane of the camera.

The adaptive control of a robot based on Gennet was created; this is a combination of a neural network and a genetic algorithm.

The assembly also has a PID controller (proportional-integral-derivative).

The control of the robot is expressed by Equation (9).

$$F({\varphi }_t,{\dot{\varphi }}_t)\to \left({\ddot{\varphi }}_{t+1}\right)$$

(9)

Here $\varphi =({\varphi }_1{\varphi }_2\dots {\varphi }_5)$ is the angle vector for each joint.

The movement instability is expressed as presented in Equation (10).

$${\varphi }_{t+1}={\varphi }_{t+1}^{\prime }+\Delta {\varphi }_{t+1}$$

(10)

Here t is the control cycle and $\Delta {\varphi }_{t+1}$ shows 3 error sources:

1.

Noise;

2.

The friction between the ground and the robot;

3.

The ground’s irregularity.

The force vector is computed as presented on Equation (11).

$$Q=M\left(\theta \right)\ddot{\theta }+C(\theta ,\dot{\theta })\dot{\theta }+F\left(\dot{\theta }\right)+G\left(\theta \right)$$

(11)

Here $\theta$ represents the joints’ coordinate vector, $\dot{\theta }$ is the joints’ speed vector, $\ddot{\theta }$ is the joints’ acceleration vector, M is the matrix of inertia, C is the Coriolis force, F is friction, G is gravity, and Q is the vector of force.

During the process of training, the function of fitness can be calculated, knowing that 100 random chromosomes were created, represented by 8 × 50 × 50 binary digits.

The new fitness function was calculated, in which 100 random chromosomes were produced, as presented in Equation (12).

$$f=\prod _1^{40}A\left({\varphi }_{t+1}\right)\left(\sum _1^{40}\left(D({\varphi }_t,{\varphi }_t^{\prime })·\left(1-\frac{N_p}{50}\right)·Z\left(S({\varphi }_{t+5},M)\right)\right)\right)$$

(12)

Here $S({\varphi }_{t+5},M)$ is the gravity center, $Z\left(S\right(\ast \left)\right)$ shows if $S(\ast )$ is still inside the ZMP (zero moment point) after five cycles. $N_p$ represents the neurons’ number of chromosomes p, as presented in Equation (13).

$$Z\left(S(\ast )\right)=\left\{\begin{array}{c}\hfill 0S({\varphi }_{t+i},M)\in ZMP\\ \hfill 1S({\varphi }_{t+i},M)\in ZMP\end{array}\right.(i=5)$$

(13)

Here $A\left({\varphi }_t^{\prime }\right)$ is the angle of output; here 0 is negative; and 1 is positive.

The individuals’ selection method with minor changes in joint angles is shown on Equation (14).

$$D=({\varphi }_t,{\varphi }_t^{\prime })=1/\sqrt{\sum _1^5{({\varphi }_t-{\varphi }_t^{\prime })}^2}$$

(14)

To compute the probability $P_S$, it can be used to use the fitness value as shown in Equation (15).

$$P_S=f_S/\sum _{i=1}^n{f}_i$$

(15)

Further on, it shall be presented on Equation (16) the motion for each robotic arm joint in a gravitational field.

$${\tau }_i=I_i{\ddot{\theta }}_i+m_{i}g{r}_{i}sin\left({\theta }_i\right)$$

(16)

where ${\tau }_i$ is the i joint’s torque, $I_i$ is the i joint’s moment of inertia, ${\ddot{\theta }}_i$ is the i joint’s angular acceleration, $m_i$ is the mass of the link attached to the joint i, g is gravitational acceleration, $r_i$ is the distance from the joint i to the i link’s center of mass, and ${\theta }_i$ is the i joint’s angular position.

Equation (17) presents forward kinematics that is used to calculate the position of the end-effector.

$$\left\{\begin{array}{c}\hfill x=\sum _{i=1}^n{L}_{i}cos\left({\theta }_i\right)\\ \hfill y=\sum _{i=1}^n{L}_{i}sin\left({\theta }_i\right)\end{array}\right.$$

(17)

Here x and y are the end-effector’s Cartesian coordinates, n is the quantity of joints, $L_i$ is the i link’s length, and ${\theta }_i$ is the i joint’s angular position.

The genetic algorithm’s fitness function is presented in Equation (18).

$$\mathrm{fitness}=\frac{1}{\mathrm{distance}+e}$$

(18)

Here distance is the distance between the target position and the end-effector, and e is a little value to prevent division by zero.

3.3. Learning to Write

To teach a robotic arm to write or draw, there is a lot of work on the software part too, but there is also a problem with the hardware part too.

Equation (19) shows forward kinematics computations for the end-effector.

$$\left\{\begin{array}{c}\hfill x=L_{1}cos\left({\theta }_1\right)+L_{2}cos({\theta }_1+{\theta }_2)\\ \hfill y=L_{1}sin\left({\theta }_1\right)+L_{2}sin({\theta }_1+{\theta }_2)\end{array}\right.$$

(19)

where x and y are the end-effector’s Cartesian coordinates, $L_1$ and $L_2$ are the robotic arm segment’s length, and ${\theta }_1$ and ${\theta }_2$ are the angles of the joint.

Equation (20) shows the inverse kinematics computations for the end-effector.

$$\left\{\begin{array}{c}{\theta }_1=arctan2(y,x)-arctan2(L_{2}sin\left({\theta }_2\right),L_1+L_{2}cos\left({\theta }_2\right))\\ {\theta }_2=arccos\left(\frac{x^2+y^2-L_1^2-L_2^2}{2L_1{L}_2}\right)\end{array}\right.$$

(20)

It is really hard to fix a marker on the gripper of the robotic arm without the marker moving when touching a hard surface such as the writing surface or the whiteboard. After each contact with the whiteboard, the marker would move a little bit and after the next repetition of writing, the marker was not in the same place and the writing was done differently, in different positions, or worse, the result did not reproduce the desired or pre-programmed letter. In the worst case, the marker would become lost and fall off the grippers of the robotic arm.

Many tests have been done, but the result was the same.

A solution for this problem was needed. The solution was to fix the marker better and not use the robotic arm gripper.

The fixing of the marker was done using screws, metal plates, and a sponge that fixed the marker so that it did not slip off the mounting system. The fixing system is presented in Figure 5. Actually, this system for fixing is a prototype; of course, it needs much improvement, but for what was needed, it worked very well.

The aluminum plate from the top is placed in such a way that the marker will be at the bottom of the gripper; thus, the weight will be dispersed more, and it would be so heavy for the robotic arm to lift it. Also, the mounting of the marker is done in a way so that the robotic arm writes letters not in the front but on one of the sides of it. This way, it can have the possibility to write more complex letters because it has a more complex movement path.

On the first image of Figure 6, an application made in LabVIEW can be seen where the robotic arm can be taught to write.

On the first column is configured the RS-232 protocol, which is used to communicate with the robotic arm. There is configured the COM1 port as the serial port, with the baud rate of 115200, 8 data bits, no parity, 1 stop bit, and no flow control.

On the second column, there are buttons to set the robotic arm in remote mode. The first button (SSC-32 Version) is to read the version of the SSC-32 robot controller. The second button (Initialize Motors) is used to test all digital ports where the motors are connected and to test and initialize the motors. The third button (All Servos 1500) is to place the robotic arm in home mode or in the shape of the capital gamma letter (Γ). This can be put, but the middle position of each motor or the value 1500 is set.

The motors can move at angles between 0° and 180°, and this movement angle can be set by writing values between 500 and 2500 according to Equations (21) and (22). In this way, the value for 90°, or the middle position, will be 1500. The robotic arm is constructed mechanically in such a way that if all the motors are put in the middle position (with a value of 1500), it will be in home mode or in the shape of the capital gamma letter (Γ).

$$\alpha =\frac{\Delta \omega }{{180}^{\circ }}=\frac{2500-500}{{180}^{\circ }}=11.\left(1\right)$$

(21)

$$1^{\circ }\approx 11$$

(22)

The fourth button (Move) is the move button when the robotic arm can be taught to do any task, or in our case, to write.

The fifth button (Save) is the button that saves the values of motor movement in text files, so they can be read by another program. This way, the robotic arm can execute what is taught.

The program also has sliders that can move each motor of the robotic arm (Base, Shoulder, Elbow, Wrist, Wrist Rotate (not mounted), Grip), but also a soft control underneath where each motor value can be set exactly with approximately a resolution of 0.1°.

On the second image of Figure 6, it can be seen that the LabVIEW application that the LabVIEW application commands the movements that the robotic arm has learned. The program is similar to the teaching program, with the only difference that this application does not have movement sliders because this app reads the text files that the previous application saved. These text files contain the positions of each movement of the robotic arm while writing the desired letter.

There is also another way to program the robotic arm, perhaps in a more natural way, by moving the robotic arm with a mouse. The motion of the robotic arm with the mouse can follow the movements of the robotic arm programmer. This method can have some advantages, but also some drawbacks.

On the third image of Figure 6, the LabVIEW application that controls the robotic arm with mouse movements can be seen. The first two columns are similar to those of the applications before, but the rest of the application differs. There are three indicators of the mouse movement (Horizontal, Vertical, and Scroll). These indicators indicate the left-right, up-down, and the scroll movements of the mouse.

With left-right movement, the base of the robot is moved; with up-down movement, the shoulder of the robot is moved; and with scroll movement, the elbow of the robot is moved. There are two LEDs that indicate the mouse clicks (Left and Right buttons) and an indicator for the Grip value of the robot. There is also an indicator of whether the Left or Right mouse buttons are being pressed or not. There is also a Wrist value indicator, which is not used but is made to replace the Scroll value of the mouse, which moves the elbow of the robotic arm. In other words, the mouse scroll wheel can move the elbow or wrist of the robotic arm. In our situation, it moves the elbow of the robotic arm. As can be observed, the Wrist or Wrist Rotate motors of the robotic arm cannot be controlled due to the fact that a standard mouse does not have more degrees of freedom. It is needed to use a gaming mouse with more buttons, even a joystick or a gamepad, to be able to control more motors from the robotic arm. Even without controlling the Wrist or Wrist Rotate motors, the robotic arm can be controlled quite well to complete the task of writing letters.

The reduced number of motors may be a drawback due to the reduced degrees of freedom of a computer mouse, but the precision of mimicking the human arm with a mouse can be an advantage when creating such a task as writing letters.

The mouse can also be used to connect a device with an accelerometer like a fly mouse, a mobile phone, or a smart watch to the system, which can mimic hand gestures to control the robotic arm. This can be done really easily because there are apps that can convert smartphone or smart watch movements into mouse movements. These applications are used in fact for presentations but can also be used successfully in robotics.

3.4. Solar Tracker

For a solar tracker, there is a need to be a solar azimuth ($\gamma$) computation as shown on Equation (23).

$$\gamma =arctan2(\sin ({\theta }_{\mathrm{solar}}-{\theta }_{\mathrm{tracker}}),cos({\theta }_{\mathrm{solar}}-{\theta }_{\mathrm{tracker}})sin\left({\varphi }_{\mathrm{lat}}\right)-tan\left(\delta \right)cos\left({\varphi }_{\mathrm{lat}}\right))$$

(23)

Here ${\theta }_{\mathrm{solar}}$ is the solar zenith angle, ${\theta }_{\mathrm{tracker}}$ is the zenith angle of the tracker, ${\varphi }_{\mathrm{lat}}$ is the location latitude, and $\delta$ is the solar declination angle.

There is also a need to compute the solar elevation angle ($ϵ$) as shown on Equation (24).

$$ϵ=arcsin(\sin \left({\varphi }_{\mathrm{latitude}}\right)sin\left(\delta \right)+cos\left({\varphi }_{\mathrm{latitude}}\right)cos\left(\delta \right)cos\left({\theta }_{\mathrm{solar}}\right))$$

(24)

There is also a need to compute the orientation angle adjustment of the tracker (${\theta }_{\mathrm{tracker}}$) as shown on Equation (25).

$${\theta }_{\mathrm{tracker}}=\mathrm{feedback}\_\mathrm{angle}+\mathrm{error}\times \mathrm{proportional}\_\mathrm{gain}$$

(25)

Here feedback_angle is the tracker’s current angle, the error is the difference between the current solar azimuth angle and the desired azimuth angle, and proportional_gain is the control system’s proportional gain.

It will be used. Four photoresistors or pyrheliometric sensors will be used in the arrangement shown in Figure 7 using walls to delimit the four movement quadrants of the robot on the two axes (0x and 0y). The system will use a Cartesian coordinate system. One can use a tilt sensor in MEMS (Micro-Electro-Mechanical Systems) technology to provide additional inclination.

Photoresistors, or LDRs (light-dependent resistors), were used for the sensors in the solar tracker robot.

The pirheliometric sensor can be used as an alternative to the sensors used in the solar tracker robot.

The prototype will be controlled by an ATmega328 microcontroller board.

Figure 8 displays the additional circuitry utilized alongside the microcontroller board. This circuit includes four photoresistors, each in series with a 1 kΩ resistor, connected to the microcontroller’s first four analog input ports. Additionally, two 10 kΩ potentiometers are employed to adjust the rotation speed and the angle movement tolerances, connected to the analog input ports A4 and A5.

The motors are connected to the digital ports D9 and D10.

The photoresistors are connected in the arrangement shown in Figure 7; this way, the robot follows the position of the sun, moving (horizontal and vertical) in its direction. If the robot also has a solar panel, it can rotate the solar panel in the direction of the sun, increasing its efficiency by up to 30%.

The microcontroller has software that reads the photoresistors and moves the servomotors accordingly.

The algorithm can be extended to wind turbines simply by replacing photoresistors with wind sensors or anemometers.

In Figure 9, it can be seen the circuit used for the FPGA board to create an ATmega328 microcontroller that is used to control the solar tracker. The circuit was generated using the Xilinx Vivado software. There can be seen three input buses. There was the S_AXI_HP0 (Slave Advanced eXtensible Interface High Performance) bus. Here the data port and the ACLK (Auxiliary Clock) were used, but not the FIFO_CTRL (First In First Out Control). For the output, all four output buses were used: the DDR (Double Data Rate Random-Access Memory), FIXED_IO (Fixed Input/Output), FCLK_CLK0 (Frequency-Programmable Clock), and FCLK_RESET0_N (Frequency-Programmable Clock Reset).

In Figure 10, it can be seen the package of the FPGA seen in the PlanAhead tool of the Xilinx ISE WebPACK Design Software. Actually, here the pin from the ATmega328 microcontroller built on the FPGA can be seen. The pin out of the ATmega328 microcontroller is made to know where all the pins are routed. Actually, when the pin out is made, the pins of the microcontroller are routed to different interfaces present on the FPGA development board. For example, some pins are routed to the serial interface, while other pins are routed to the GPIO. There is also a possibility in other designs (more advanced microcontrollers) to route pins to audio, Ethernet, or video ports present on the FPGA development board. This is not the case for the ATmega328 microcontroller, where most of the pins are routed to the GPIO, because we need digital input, digital output, analog input pins, and the serial interface. For the solar tracker, only the digital output and the analog input pins were used; the rest of the pins (digital input and serial interface) were implemented only to have the full microcontroller built on the FPGA in order to be able to implement other designs on the microcontroller too. This image just gives an idea of how complex the pin out of the ATmega328 microcontroller built on the FPGA is.

In Figure 11, it can be seen that the ATmega328 microcontroller device built on the FPGA also appears in the PlanAhead tool of the Xilinx ISE WebPACK Design Software. Here, it can actually be seen how the circuit blocks would look physically on the FPGA.

4. Results

4.1. Gravity Effects

In Figure 12, it can be seen different experimental results of the robotic arm, where the position of the robotic arm is computed in space using evolutionary methods. The robotic arm was moving according to the calculations made.

On the first three images, it can be seen that only colored paper stickers are used on the robotic arm joints. In the first two images, it can be seen that the robotic arm has colored paper stickers with the same color (blue) at the joints, making it difficult to detect which joints are the base elbow or wrist because they are all marked with the same color. There is a method to differentiate each joint by moving each joint at a time; this is the joint that will not change its position and will be the joint that is moving, but when the robotic arm is static, there is no way to differentiate the joint because they are marked with markers of the same color.

On the third image, it can be seen that the robotic arm joint is marked with colored paper stickers of different colors (blue, yellow, and red), but being a sticker, it does not have a 3D shape. When the robotic arm rotates perpendicularly to the camera plane, these markers will barely be seen. This way, it can be used for bottle caps with different colors glued at the robotic arm’s joints (as seen in the fourth image), which will be seen even if the robotic arm moves in a perpendicular position of the camera plane.

The fifth and sixth images show how guide lines can be drawn to get the robotic arm to know the movement circles in the center of each joint.

The last two images also show a target point (the green bottle cap) that the robotic arm can use to track the target point. There may be more methods to obtain the coordinates of the robotic arm’s joints. One can use the Hough circles method to detect colored bottle caps. The other method can be simple image filtering with color recognition using color thresholds for each color.

Finally, the robotic arm can improve its precision with the genetic algorithm by using repeated movements in a loop. After each generation, the robotic arm will become more and more exact in the position indicated by the target point.

On all these images, it can be seen that the robotic arm makes different movements without being influenced by the gravity conditions.

In Figure 13, it can be seen the trajectory plots of the robotic arm.

4.2. Learning to Write

In Figure 14, the robotic arm can be seen, which was thought to write the “H” letter. In this image, it is also presented how the marker is fixed for the robotic arm. As can be seen, the robotic arm succeeded in writing a letter and can be programmed to write any letter due to the fact that the “H” letter is not one of the easiest letters to write.

4.3. Solar Tracker

In Figure 15, it can be seen the circuitry with the development board and breadboard to create the solar tracker robot. It should be mentioned that outside the breadboard there are the photoresistors and the potentiometers.

As can be seen, the solar tracker robot is built using two servomotors, four photoresistors in the arrangement shown in Figure 7, a microcontroller board with control software, and a breadboard with the circuit presented in Figure 8. The motors are glued together with a hot silicone glue gun (one motor vertically, the other horizontally). The whole secret lies in how the servomotors are glued together to enable the solar tracker robot to make horizontal and vertical movements. The other secret is how to place the photoresistors, which is presented in Figure 7.

The code is built into the ATmega328 microcontroller, which is programmed to read the photoresistors and move the servomotors accordingly.

The system allows movements in horizontal and vertical directions. The four photoresistors, which are used to collect light from the sun. The four dividing walls for the photoresistors are used to get the light information according to the four quadrants of the x0y Cartesian coordinate system. The additional circuitry for the solar tracker consists of resistances for the photoresistors and potentiometers, which are used for setting the tolerance and speed of the solar tracker.

Due to the fact that the four photoresistors or LDRs (light-dependent resistors) are divided with four walls and there are also two servomotors, it could be accepted that the robot can move in the four quadrants (up-down, left-right) of the x0y Cartesian coordinate system according to the position of a light source.

5. Discussion

5.1. Gravity Effects

As it was seen, the robotic arm was tested in a gravity environment, which did not influence its normal behavior. The robotic arm performed classic movement tasks, which were performed as planned under gravity environment conditions. The robotic arm was controlled with evolutionary methods using genetic algorithms that mimicked the movement of a human hand.

The robotic arm shows surprising versatility in gravity conditions. It effectively keeps up with solidity and performs tasks under gravity.

The robotic arm has precision and the ability to perform tasks under gravity, representing its true capacity for applications requiring precise control.

The force requirements for the robotic arm are discernibly reduced under gravity, allowing it to carry higher payloads without compromising accuracy or safety.

The flexibility of robotic arms to gravity has critical implications for space investigation, as it empowers these arms to perform tasks under conditions of gravity with improved control.

5.2. Learning to Write

As it was presented, a robotic arm was made, which was taught to write.

The hardest part was mounting the marker on the robotic arm. The marker had to be able to not move or slip from the gripper of the robotic arm.

5.3. Solar Tracker

A solar tracker robot was presented that was created using four photoresistors, two servomotors, and a microcontroller board.

The arrangement of the photoresistors and the circuitry that was used to create the solar tracker robot were presented.

It was also presented how to create a microcontroller architecture on an FPGA to be used to control a solar tracker.

The microcontroller with software controls the solar tracker. No actual microcontroller was used, but a microcontroller architecture was created on the FPGA because of its greater flexibility.

In case a new microcontroller is needed with better performances, more pins or a higher processing frequency can be changed only by reprogramming; there is no need to replace a microcontroller physically, as it would have been needed when using an actual microcontroller chip.

The solar tracker tracks the sun or any light source controlled by the microcontroller architecture built on the FPGA platform.

The robotic arms behaved really well in all three test conditions, so it could be said that the presented genetic-algorithm-controlled robotic arms are robust and versatile.

6. Conclusions

6.1. Gravity Effects

It is possible to further improve the genetic algorithm by running it on different platforms, such as an Arduino board. The current system was developed on a Raspberry Pi using Python and later ported to FPGA on a Zynq-7000 SoC, like the Zybo or the ZedBoard, but it can be implemented in C or Java as well.

6.2. Learning to Write

Further enhancements would be to implement drawings for the robotic arm.

Another enhancement would be to control the application on other platforms, maybe some embedded ones such as the Raspberry Pi or on the Zynq SoC with FPGA like the ZedBoard or Zybo.

The implementation was done in LabVIEW, but porting to a programming language like Python would facilitate the implementation on embedded platforms.

6.3. Solar Tracker

Further enhancement of the system could be the implementation of the system with pirheliometric sensors as a replacement for photoresistors.

Another enhancement would be to implement the system on another development board, such as the Raspberry Pi.

Further enhancement can be done by using another FPGA board, such as the Digilent Zybo.

Other enhancements can be made by replacing the servomotors with more powerful motors that are able to move a larger solar panel. Another enhancement would be to replace the sensors with wind sensors and implement the system into wind turbines that track the wind direction to create wind tracker robots.

The study was not applied to a KUKA or another precise robot due to cost issues; the author had a reduced budget, and he had to work with what he had in the laboratory. The system worked very well even on a less accurate robot, like the Lynxmotion robotic arm.

The most beneficial goal would be to test the genetic algorithm on more advanced robotic arms like the SCORBOT-ER III or a KUKA industrial robotic arm. If the system behaves and has similar results as the tested robotic arm, then it could be said that the genetic-algorithm-controlled robotic arms are robust and versatile.