Industrial on Ronan's Blog

PID regulation : Led brightness regulation with Arduino

Tue, 16 Jan 2024 00:00:00 +0000

PID regulation : Led brightness regulation with Arduino. To get this done we’ll first do a bit of wiring and then program our Arduino.

Led wiring and control

Wiring

Our led is a Yellow led with a 2.4v forward voltage at 20mA.
Our current source (Arduino) delivers 3.3v.
Resistor calculation : R = (3.3v - 2.4 V) / 25 mA = 0.9v / 0.02A = 45Ω

We’ll wire the cathode to one of the digital I/O of the Arduino. Note, we chose the digital I/O #3 as we’ll need to use PWM (described below).

As I just had a 47Ω resistor, this will work :

Control

In order to control the brightness of the LED, we’ll use the Pulse-width modulation (PWM), or pulse-duration modulation (PDM) :

To do this, we’ll use the following function : analogWrite(pin, value)
- pin: the pin to write to.
- value: the duty cycle: between 0 (always off) and 255 (always on)

Code sample :

void setup()
{
pinMode(3, OUTPUT); 
}

void loop()
{
//Analog write
analogWrite(3, 64); 
}

Results (0, 25%, 75%, 100%) :

Led brightness regulation

Sensor

We’ll add a light sensor as wired below :

Just place the sensor in front of the LED:

Regulation

In order to regulate, we’ll use a proportional–integral–derivative controller. A PID controller is a control loop feedback mechanism (controller) commonly used in industrial control systems. A PID controller continuously calculates an error value as the difference between a desired setpoint and a measured process variable. The controller attempts to minimize the error over time by adjustment of a control variable.

Here is the code :

#include <PID_v1.h>
//Variables
double Setpoint, Input, Output;
//PID parameters
double Kp=0, Ki=10, Kd=0;

//Start PID instance
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

void setup()
{
 //Start a serial connection to send data by serial connection
 Serial.begin(9600); 
 //Set point : Here is the brightness target
 Setpoint = 100;
 //Turn the PID on
 myPID.SetMode(AUTOMATIC);
 //Adjust PID values
 myPID.SetTunings(Kp, Ki, Kd);
}

void loop()
{
 //Read the value from the light sensor. Analog input : 0 to 1024. We map is to a value from 0 to 255 as it's used for our PWM function.
 Input = map(analogRead(0), 0, 1024, 0, 255); 
 //PID calculation
 myPID.Compute();
 //Write the output as calculated by the PID function
 analogWrite(3,Output);
 //Send data by serial for plotting 
 Serial.print(Input);
 Serial.print(" ");
 Serial.println(Output); 
}

PID Parameters :

Kp accounts for present values of the error (e.g. if the error is large and positive, the control variable will be large and negative).
Ki accounts for past values of the error (e.g. if the output is not sufficient to reduce the size of the error, the control variable will accumulate over time, causing the controller to apply a stronger action).
Kd accounts for possible future values of the error, based on its current rate of change.

The Arduino 1.6.6 comes with a tool called “Serial plotter”, that might be useful to graph our data:

The measured value is note stable, probably due to the PWM. A solution would be to smooth the results by doing an average on the lasts results, in order to filter the high frequency changes.

Note : You can graph several values at the same time, you just need to send them on the same line, with a space as a delimiter.

When I disrupt the system with an external light, we clearly see that the system tries to keep the brightness at the setpoint (100) by managing the led control value :

To conclude, here is how the system is handling a change from 0 to setpoint, or from setpoint to 0 :

You’re done with PID regulation : Led brightness regulation with Arduino

Siemens PLC simulation with virtual commissioning

Sun, 14 Jan 2024 00:00:00 +0000

For Siemens PLC simulation with virtual commissioning we’ll use PLCSIM Advanced and C# co-simulation.

Configuration

We’ll run the simulator and the editor on two computers :

Simulator configuration

First let’s start an instance with the following parameters :

Once started, it should be like that :

PLC Programming

Hardware configuration

Let’s do a simple configuration as follow :

Network configuration :
- PLC_1 : 192.168.1.1/24
- IO device_1 : 192.168.1.2/24

Note : On the simulator, we have different IP addresses for all the network interfaces : Ethernet adapter, PLCSIM virtual ethernet adapter, PLC and I/Os !

With the following I/Os :

Note that you’ll need to activate this option in the project settings :

Program

Our program will be very simple ! OB1 will toggle a bit every second :

And FB1 will do a safety check between the relay output and the input feedback :

Compiling and loading

You should be able to compile and load :

Simulation

As soon as you’ll run the program, you should have an error on the feedback monitoring :

Co-simulation

To solve this issue, we’ll running co-simulation with C#. The script will check the output value (%Q9.0) and set the feedback (%I0.0) accordingly. We’ll be using sharpdevelop as IDE.

Import DLL

Importing the DLL is easy :

Then we write a short program :

/*
 * Created by SharpDevelop.
 */
using System;
using System.Threading;
using Siemens.Simatic.Simulation.Runtime;

namespace CPU1515F
{
	class Program
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("Starting simulation");
			//Use it for local instance
			//IInstance myInstance = SimulationRuntimeManager.CreateInterface("Golf8");

			//Use it for remote instance
			IRemoteRuntimeManager myRemoteInstance = SimulationRuntimeManager.RemoteConnect("192.168.1.101:50000");
			IInstance myInstance = myRemoteInstance.CreateInterface("1515F");
		
			//Update tag list from API
			Console.WriteLine("Tags synchronization");
			myInstance.UpdateTagList();
		
			//Start a thread to synchronize feedbacks inputs 
			Thread tFeedbacks = new Thread(()=>synchroFeedbacks(myInstance));
			tFeedbacks.Start();
			
			//Allow the user to quit simulation
			Console.WriteLine("Simulation running");
			Console.WriteLine("Press any key to quit . . . ");
			Console.ReadKey(true);
		}
		
		static void synchroFeedbacks(IInstance myInstance)
 {
			while(true){
				//Keep %I and %Q opposite
				myInstance.WriteBool("FB_KA1", !myInstance.ReadBool("KA1"));	
			}
		}
	}
}

And run it :

Once acknowledged, we should not have any issue.

Using the trace tool, we can confirm that it’s running perfectly fine, updating the input in around 100ms.

You’re done with Siemens PLC simulation with virtual commissioning.

Unrelated parallel machine scheduling optimization with a genetic algorithm

Sun, 14 Jan 2024 00:00:00 +0000

In this article, we will go through the process of unrelated parallel machine scheduling optimization with a genetic algorithm.

Introduction

For the Scheduling on Unrelated Parallel Machines proble the goal is to find an jobs/machines assignment to minimize the overall makespan, so the goal is to have the best balance between machines.

Not well balanced schedule

Well balanced schedule

Problem data

For our problem, we will consider n jobs to be assigned on m machines.

Processing time

First, the jobs processing time will be manage as follow :

Job assignment

We will manage the jobs/machines assignment as follow : If the job j is schedule on machine i then Xij = 1, else Xij = 0.

Genetic algorithms

Introduction

A genetic algorithm (GA) is a search heuristic that is used to solve optimization and search problems. It is inspired by the process of natural selection and the principles of genetics. The algorithm simulates the process of evolution, where the fittest individuals are selected for reproduction to produce the offspring of the next generation.

Here’s how it works in general:

Initial Population: The algorithm starts with a randomly generated population of possible solutions (individuals), often represented as strings of binary values, real numbers, or other data structures.
Selection: Individuals are selected based on their fitness, which is usually evaluated using a fitness function. The more suitable or “fit” an individual is for solving the problem, the higher its chance of being selected for reproduction.
Crossover (Recombination): Selected individuals are paired, and their genetic information is combined (crossover) to produce offspring. This mimics the natural genetic recombination that occurs during reproduction.
Mutation: After crossover, some offspring undergo mutation, where random changes are made to their genetic structure. This introduces variability and helps explore new solutions.
Evaluation and Replacement: The new generation of solutions is evaluated, and the least fit individuals are replaced by the new, more fit offspring.
Termination: The process repeats for several generations or until a termination criterion is met, such as finding a solution with sufficient fitness, a set number of generations, or convergence of the population.

Genetic algorithms are versatile and can be applied to various problems, including optimization, machine learning, scheduling, and engineering design. They are particularly useful for problems where the solution space is large, complex, and not easily navigable by traditional methods.

Genetic algorithm data structure

Genetic algorithm process

To find better solutions, the process is:
1- Evaluation: Sort the population based on chromosomes scores (fitness).
2- Selection: Choose the best chromosomes to generate the next population (natural selection).
3- Crossover: Mate the chromosomes between them by mixing their genome.
4- Mutation: As in a natural environment, some genes are changed arbitrarily.

Example

The goal is to give a practical idea of the genetic algorithm operations. We’ll consider a problem with 2 machines (m=2) and 4 jobs (n=4).

Processing times

Example for processing times

Population

Let’s generate 4 chromosomes randomly :

Example for population

Evaluation

Evaluation of the generated chromosomes :

Example for evaluation

Selection

Select only the bests chromosomes, here we’ll choose to keep 75% of the sorted population :

Example for selection

Crossover

1 – Choose two random chromosomes in the selected ones (the best ones).
2 – Merge these two chromosomes by mixing their genome.
3 – Store the new generated chromosome in the new population.
4 – Repeat the crossover operation until the new population is fully generated.

Example for crossover

Mutation

The mutation operation is not systematic. Usually, around 1% of the crossover chromosomes will go through a mutation. During this operation, we will randomly change a gene :

Example for mutation

Code example

Here is a Python implementation.

 __author__ = 'rfontenay'
 __description__ = 'Genetic algorithm to solve a scheduling problem of N jobs on M parallel machines'
 import random
 import time
# ******************* Parameters ******************* #
# Jobs processing times
jobsProcessingTime = [543, 545, 854, 766, 599, 657, 556, 568, 242, 371, 5, 569, 9, 614, 464, 557, 460, 970, 772, 886,
69, 423, 181, 98, 25, 642, 222, 842, 328, 799, 651, 197, 213, 666, 112, 136, 150, 810, 37, 620,
139, 721, 823, 351, 953, 765, 204, 800, 840, 132, 764, 336, 587, 514, 948, 134, 203, 766, 954,
537, 933, 458, 936, 835, 335, 690, 307, 102, 639, 635, 923, 699, 71, 913, 465, 664, 49, 198, 747,
931, 124, 41, 214, 246, 954, 676, 811, 295, 977, 100, 316, 453, 903, 50, 120, 320, 517, 441, 874,
842]
# Number of jobs
n = len(jobsProcessingTime)
# Number of machines
m = 2
# Genetic Algorithm : Population size
GA_POPSIZE = 256
# Genetic Algorithm : Elite rate
GA_ELITRATE = 0.1
# Genetic Algorithm : Mutation rate
GA_MUTATIONRATE = 0.25
# Genetic Algorithm : Iterations number
GA_ITERATIONS = 1000
# ******************* Functions ******************* #
def random_chromosome():
"""
Description :Generate a chromosome with a random genome (for each job, assign a random machine).
Input : -Line 2 of comment...
Output : Random chromosome.
"""
# Jobs assignment : Boolean matrix with 1 line by job, 1 column by machine
new_chromosome = [[0 for i in range(m)] for j in range(n)]
# For each job, assign a random machine
for i in range(n):
new_chromosome[i][random.randint(0, m - 1)] = 1
return new_chromosome
def fitness(chromosome):
"""
Description : Calculate the score of the specified chromosome.
The score is the longest processing time among all the machines processing times.
Input : A chromosome.
Output : The score/fitness.
"""
max_processing_time = -1
for i in range(m):
machine_processing_time = 0
for j in range(n):
machine_processing_time += chromosome[j][i] * jobsProcessingTime[j]
# Save the maximum processing time found
if machine_processing_time > max_processing_time:
max_processing_time = machine_processing_time
return max_processing_time
def crossover(chromosome1, chromosome2):
"""
Description : Crossover two chromosomes by alternative genes picking.
Input : Two chromosome.
Output : One chromosome.
"""
new_chromosome = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
# Alternate the pickup between the two selected solutions
if not i % 2:
new_chromosome[i] = chromosome1[i]
else:
new_chromosome[i] = chromosome2[i]
return new_chromosome
def evolve(population):
"""
Description : Create a new population based on the previous population.
The new population is generated by mixing the best chromosomes of the previous population.
Input : Old population.
Output : New population.
"""
new_population = [[] for i in range(GA_POPSIZE)]
# First : Keep elites untouched
elites_size = int(GA_POPSIZE * GA_ELITRATE)
for i in xrange(elites_size): # Elitism
new_population[i] = population[i]
# Then generate the new population
for i in range(elites_size, GA_POPSIZE):
# Generate new chromosome by crossing over two from the previous population
new_population[i] = crossover(population[random.randint(0, GA_POPSIZE / 2)],
population[random.randint(0, GA_POPSIZE / 2)])
# Mutate
if random.random() < GA_MUTATIONRATE:
random_job = random.randint(0, n - 1)
# Reset assignment
new_population[i][random_job] = [0 for j in range(m)]
# Random re-assignment
new_population[i][random_job][random.randint(0, m - 1)] = 1
return new_population

# ******************* Program ******************* #
# Measure execution time
start = time.time()

# Generate an initial random population
population = [[] for i in range(GA_POPSIZE)]
for i in range(GA_POPSIZE):
population[i] = random_chromosome()

# Sort the population based on the fitness of chromosomes
population = sorted(population, key=lambda c: fitness(c))
# Print initial best makespan
print “Starting makespan = %03d” % (fitness(population[0]))
#Iterate
for i in range(GA_ITERATIONS):
# Sort the population : order by chromosone’s scores.
population = sorted(population, key=lambda c: fitness(c))
#Generate the following generation (new population)
population = evolve(population)

# Print the best fitness and the execution time after iterations
print "Ending makespan = %03d" % (fitness(population[0]))
print "Execution time = %02d s" % (time.time() - start)

You’re done with Unrelated parallel machine scheduling optimization with a genetic algorithm

EtherNet/IP simulation on Fanuc Roboguide

Thu, 11 Jan 2024 00:00:00 +0000

In order to be able to do EtherNet/IP simulation on Fanuc Roboguide, we’ll go through a few configuration steps.

EtherNet/IP Introduction

Ethernet/IP (Ethernet Industrial Protocol) is an industrial communication protocol used in automation systems to connect devices such as programmable logic controllers (PLCs), sensors, actuators, and other industrial equipment. It is based on standard Ethernet and uses the TCP/IP and UDP/IP protocols for communication. It is a widely adopted protocol in industries like manufacturing, automotive, and energy.

Here are key details about Ethernet/IP:

Protocol Overview

Standard: Ethernet/IP is defined by the ODVA (Open DeviceNet Vendors Association) and is built on the IEEE 802.3 Ethernet standard.
Application Layer: It uses the Common Industrial Protocol (CIP) for communication. CIP is the application layer that provides services for devices in industrial automation systems, such as devices connected to ControlNet, DeviceNet, and EtherNet/IP.
Communication Media: Ethernet (100Base-TX, 1000Base-T, etc.), using standard Ethernet cables and hardware.

Key Communication Types

Explicit Messaging: Uses TCP/IP to send messages between devices for configuration, diagnostics, and data exchange.
Implicit Messaging (I/O Messaging): Uses UDP/IP for real-time data exchange (e.g., control signals, process data) between devices. This is typically used for high-performance applications where low latency is crucial.

Ethernet/IP Architecture

Devices: Ethernet/IP networks consist of various devices like PLCs, I/O modules, HMIs, drives, and sensors. These devices communicate with each other through Ethernet.
I/O Devices: The most common devices in Ethernet/IP networks are I/O devices (e.g., sensors and actuators) that use implicit messaging to exchange process data.
Controller-to-Device Communication: The PLC or controller exchanges data with the field devices via explicit or implicit messaging, depending on the requirements of the application.

Robot creation in Roboguide

While doing the robot creation process, install the following options :
- R784 - Ethernet/IP Adapter
- R785 - Ethernet/IP Scanner

Network configuration

Configure the network as shown below.

Enable specific variable for Ethernet/IP simulation in Roboguide

You’re done with EtherNet/IP simulation on Fanuc Roboguide !