Delta Robot and Conveyor Example: A Glimpse into Industrial Automation

Part 1: What is a Delta Robot and What Does It Do?

In today’s world, robotics is transforming how we teach and learn about automation. One such educational tool is the Delta Robot, a precision parallel robotic arm with three degrees of freedom (3-DOF), meaning it can move its end-effector in X, Y, and Z coordinates. The Delta Robot serves as a scaled-down version of the large robotic arms commonly used in industries but is primarily used for educational purposes in school laboratories.

Its main purpose is to show to students, particularly in Control and Automation fields, the fundamental principles of robotic arms, including kinematics and precision handling. Large industrial robotic arms are not feasible for lab environments due to their size and complexity, so the Delta Robot provides a more manageable and safer alternative for hands-on learning.

Figure 1: Acrome Delta Robot

Part 2: Kinematic Equations – The Core of Robotic Motion

At the core of the Delta Robot’s functionality lies kinematic equations, which describe the robot’s motion. These equations allow us to calculate the exact position and orientation of the robot’s end-effector based on joint angles. There are two primary types of kinematic equations:

  • Forward Kinematics: This method calculates the position of the robot’s end-effector based on the angles of its joints, effectively converting angles into X, Y, and Z coordinates.
  • Inverse Kinematics: This is the reverse process, where we specify the desired position of the end-effector, and the system calculates the necessary joint angles to achieve that position.

By mastering these equations, students can understand how robots are programmed to move accurately within their workspace.

Part 3: Conveyor Example Using a Delta Robot

In this educational setup, we applied the Delta Robot in a conveyor system example. A conveyor is a mechanical device that moves objects from one location to another. This project demonstrated how a Delta Robot can be integrated with a conveyor to recognize objects and perform precise handling tasks. While industrial robots are often seen in factories working alongside conveyors, in this case, the Delta Robot will be able to operate in a school lab environment, showcasing a similar yet smaller-scale interaction.

The custom conveyor designed for this setup allows the Delta Robot to detect various materials moving along the belt and place them in specific positions. One of the most intriguing parts of this process was object recognition—where the robot identifies objects, detects their shapes, and calculates their position in real-world coordinates.

Figure 2: Flow Chart for Conveyor App

Part 4: Converting Pixel to Real-World Coordinates

To accurately place objects, the Delta Robot must first convert the objects’ position from pixel coordinates (captured by the camera) into real-world coordinates that it can understand. We achieved this using the following formula:

Formulas to calculate the pixels vs real-world coordinates
Scaling calculations

Where:

  • OffsetX and OffsetY are real-world offsets,
  • PixelX and PixelY are the object’s position in the camera’s field,
  • CenterX and CenterY are the pixel coordinates of the camera’s center,
  • ScaleX and ScaleY are the scaling factors converting pixel distance to real-world units.

By using this conversion, the robot can accurately map the detected object’s position on the conveyor belt, ensuring it picks up and handles objects precisely.

Part 5: Detecting Shapes with the Delta Robot

In our object recognition process, the Delta Robot first captures an image of the conveyor system. Using image processing techniques such as thresholding and contour detection, the system identifies shapes like squares, triangles, and circles. Once a shape is detected, the robot calculates its centroid (center of the shape) and applies the pixel-to-real-world conversion formula to determine its precise location on the conveyor.

Below is the algorithm and pseudo code that explains how to detect the object.

Detect and Pixel to Real Coordinate Algorithm:

The Delta Robot first captures an image of the conveyor system in the object recognition process. Using image processing techniques such as thresholding, eroding and contour detection, it identifies shapes like squares, triangles, and circles. When a shape is detected, the robot calculates its centroid and applies the pixel-to-real-world conversion formula to determine its precise location. The algorithm begins by initializing the camera and capturing an image, which is then flipped horizontally. A perspective transformation is applied using predefined corner points, and the resulting image is converted to grayscale. Next, binary thresholding and erosion operations are used to enhance the shapes in the image. Contours are detected, and properties such as the centroid, bounding shapes, and aspect ratio are calculated for each contour.

If the Y-coordinate of the centroid is near a specified value, the type of shape is determined, and labels such as square, triangle, or circle are displayed on the console. The centroid of each shape is marked, and the current time is recorded. If the shape has not been logged before, its data is recorded with a timestamp, and the coordinates are converted to the robot’s real-world system. When the coordinates are valid, they are printed along with the shape name, and the coordinates are returned. Throughout this process, the robot adjusts its movements based on the detected shape, allowing it to pick up and place objects accurately.


Detect and Pixel to Real Coordinate Pseudo Code:

FUNCTION detect()
    INITIALIZE camera
    READ frame from camera
    FLIP frame horizontally
    DEFINE centroids as predefined coordinates
    DEFINE pts1 and pts2 for perspective transformation
    APPLY perspective transformation to the frame
    CONVERT transformed image to grayscale
    APPLY binary threshold
    ERODE  the threshold image
    FIND contours in the image
    DEFINE line_y as 350
    DRAW horizontal line on the image
    FOR each contour DO
        APPROXIMATE contour shape
        CALCULATE contour properties (centroid, bounding rectangle, aspect ratio)
        IF centroid_y is near line_y THEN
            PRINT width and height
            DEFINE shape_name as empty string
            DETERMINE shape based on sides and aspect ratio
                IF square THEN DISPLAY "Square"
                ELSE IF triangle THEN DISPLAY "Triangle"
                ELSE IF circle THEN DISPLAY "Circle"
            DRAW circle at centroid position
            GET current_time
            IF shape is new THEN
                LOG shape data with timestamp
                CONVERT coordinates to robot's real-world system
                IF coordinates are valid THEN
                    ADJUST and PRINT coordinates with shape name
                    RETURN coordinates and label
    RETURN None
END FUNCTION

Depending on the detected shape, the robot can adjust its movements to ensure the object is picked up and placed correctly. For instance, if the robot identifies a square, it uses the centroid coordinates to guide its gripper to the correct position, showcasing the power of automation.

Conclusion: Bringing Automation to the Classroom

This project showed the Delta Robot’s potential for students, highlighting its ability to perform tasks such as object recognition, precise motion, and shape detection—skills essential for real-world automation. Although the conveyor project has not yet been integrated into the educational environment, the progress made with the Delta Robot lays a promising foundation for future applications. It continues, and will continue, to serve as a valuable teaching tool, preparing students for the complexities of industrial automation systems.

Items used in the example system
Figure 3: Camera View of the Delta Robot, Detect Centroid Algorithm

In conclusion, this project shows the Delta Robot’s potential for students, highlighting its ability to perform tasks such as object recognition, precise motion, and shape detection — the essential skills for real-world robotic process automation (RPA). Although this is a conceptual digital conveyor project, the progress made with the real Delta Robot hardware lays a promising foundation for real-world applications.

ACROME’s Delta Robot continues to be a valuable teaching tool, preparing students for the complexities of industrial automation systems.

References:

Craig, J. J. (2005). Introduction to robotics: Mechanics and control (3rd ed.). Pearson.

University of Washington Receives Next-Gen Seismic Testing Technology from QuakeLogic

QuakeLogic is proud to deliver its next-generation Ironcore Bi-Axial Shake Table to the University of Washington—powered by magnetic linear motors, making it the quietest, most precise, and most efficient biaxial shake table on the market today.

This state-of-the-art system joins an elite lineup, including a recent deployment at CALTECH, and is designed to elevate seismic education and research across leading academic institutions.

To further enhance the hands-on learning experience in structural dynamics, we also provided a 6-story modular plexiglass model structure. This tool enables students to directly observe and analyze real-time structural behavior under simulated earthquake loading, making abstract theory visible and tangible.

Key Features of the IRONCORE Bi-Axial Shake Table:

👉 Bi-Axial Motion – Two lateral degrees of freedom for complex seismic testing

👉 High Capacity – ±2g acceleration at 50 kg (or ±1g at 100 kg), ±125 mm stroke, up to 15 Hz frequency

👉 Magnetic Linear Motors – Frictionless, ultra-quiet, and low-maintenance performance

👉 Closed-Loop PID Control – Precision motion tracking and waveform fidelity

👉 Versatile Inputs – Supports both standard and custom seismic waveforms

👉 Plug & Play – Easy setup, operation, and industrial-grade reliability

👉 EASYTEST Software – Streamlined test setup, real-time monitoring, and data analysis


  • Built to advance education.
  • Designed to accelerate research.
  • Engineered for real-world seismic simulation.

Learn more about the Ironcore system:
👉 https://www.quakelogic.net/_small-scale-shaketables/biaxial-iron-core

Browse our full catalog of small-scale shake tables:
👉 https://quakelogic.net/small-scale-shaketable-catalog

Need something larger?

We also design, deliver, and install large-scale shake tables, actuators, Universal Testing Machines (UTMs), loading frames, and custom lab equipment for civil, mechanical, and aerospace engineering programs.

📩 Let’s talk about your lab’s needs: sales@quakelogic.net
📞 Or schedule a live demo: +1-916-899-0391


#EarthquakeEngineering #ShakeTable #SeismicTesting #StructuralDynamics #EngineeringEducation #UniversityOfWashington
#QuakeLogic #CivilEngineering #ResearchLab #StructuralEngineering
#LabEquipment #MagneticMotors #STEMEducation #ModernTesting
#InnovationInEducation #HandsOnLearning

Generating Fragility Curves for Seismic Risk Assessment

In the field of performance-based earthquake engineering, fragility curves are indispensable tools. These probabilistic functions describe the likelihood that a structure or component will exceed a certain damage state when subjected to varying levels of seismic intensity—typically measured using Spectral Acceleration (Sa) or Peak Ground Acceleration (PGA).

At QuakeLogic, we help researchers, engineers, and emergency planners develop and automate fragility analysis as part of seismic resilience studies. This blog post introduces a fully open-source Python script developed by our team that reads structural response data and generates fragility curves for multiple damage states.

What Are Fragility Curves?

A fragility curve is a cumulative distribution function (CDF) that defines the conditional probability:

P(Damage ≥ State | Intensity Measure)

This means that, for a given level of shaking (e.g., 0.3g Sa), the curve tells you the probability that a structure will exceed a limit-state such as Moderate or Complete damage.

We typically use lognormal distributions to model fragility because they capture the exponential rise in damage probability with increasing shaking intensity.

Engineering Demand Parameters (EDPs) and Intensity Measures (IMs)

In seismic fragility analysis, the relationship is between:

  • EDP (Engineering Demand Parameter): A measurable response of the structure.
  • IM (Intensity Measure): A scalar value representing the strength of ground shaking.

Common EDPs:

  • Maximum interstory drift ratio (MIDR) – most widely used for buildings
  • Peak floor acceleration
  • Residual drift
  • Relative displacement
  • Roof displacement
  • Member strains or rotations (for local component fragility)

Common IMs:

  • PGA (Peak Ground Acceleration)
  • Sa(T1) – Spectral acceleration at fundamental period (T1)
  • PGV (Peak Ground Velocity)
  • Arias Intensity
  • CAV (Cumulative Absolute Velocity)

Choosing the right IM and EDP depends on the structure type, the available data, and the analysis objective.

Understanding the Fragility Curve Plot

The plot generated by the code shows the fragility curves for multiple damage states. Here’s how to read it:

  • X-axis: Intensity Measure (IM)
    In our example, this is Sa(T1) (spectral acceleration), but it can be PGA, PGV, or any other meaningful measure of shaking intensity.
  • Y-axis: Probability of Exceedance
    This is the probability that the structure’s response (EDP) will exceed the defined threshold for each damage state.

Interpretation:

A steeper curve implies a rapid transition from low to high damage probability — common for brittle systems or clearly defined performance thresholds.Methodology Overview

As the intensity of shaking (IM) increases, the probability of damage naturally increases.

Fragility curves slope upwards — from 0 to 1 — showing this increasing probability.

Robust structures have curves that shift rightward, indicating a lower probability of damage at a given IM.

  1. Input Data: Simulated or observed structural responses (e.g., drift ratios) vs. seismic intensities.
  2. Damage States: Thresholds for damage classification (e.g., 1%, 3%, 4%, 5% drift).
  3. Binning: The Sa values are grouped and used to calculate the fraction of samples exceeding each damage threshold.
  4. Curve Fitting: We fit a lognormal CDF to the exceedance probabilities using non-linear regression.
  5. Visualization: Fragility curves are plotted for each damage state.

Example Output

Input Format (input.txt)

A simple tab-separated file with the following columns:

Sa_T1_g    MaxDrift_ratio
0.1        0.0043
0.15       0.0098
...        ...

You can download an example file here.

Python Code: Fragility Curve Generator

################################################################################
# Fragility Curve Generator for Seismic Risk Analysis
#
# This script calculates and visualizes fragility curves for structural
# components or systems based on nonlinear response data from a suite of
# ground motions.
#
# Fragility curves represent the conditional probability that a structure
# will exceed a predefined damage state for a given ground motion intensity
# measure (IM), typically spectral acceleration (Sa). These curves are
# essential tools for probabilistic seismic risk assessment and
# performance-based earthquake engineering.
#
# The script uses a lognormal cumulative distribution function (CDF) to fit
# observed probabilities of exceedance derived from drift thresholds and
# structural response data. Drift ratios are compared against damage state
# thresholds to calculate these probabilities at various IM bins.
#
# Generated by: QuakeLogic Inc.
# Contact: support@quakelogic.net
################################################################################

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import lognorm
from scipy.optimize import curve_fit

def run():
    try:
        df = pd.read_csv("input.txt", sep='\t')
    except FileNotFoundError:
        print("❌ input.txt not found. Please ensure it exists in the working directory.")
        return

    IMs = df['Sa_T1_g'].values
    EDPs = df['MaxDrift_ratio'].values

    damage_states = {
        'Slight': 0.01,
        'Moderate': 0.03,
        'Extensive': 0.04,
        'Complete': 0.05
    }

    fragility_results = {}
    unique_IMs = np.linspace(min(IMs), max(IMs), 20)
    tolerance = 0.05

    for ds, threshold in damage_states.items():
        prob_exceed = []
        for im in unique_IMs:
            edp_subset = EDPs[np.abs(IMs - im) < tolerance]
            if len(edp_subset) > 0:
                prob = np.mean(edp_subset >= threshold)
            else:
                prob = 0
            prob_exceed.append(prob)

        def lognorm_cdf(x, mu, sigma):
            return lognorm.cdf(x, s=sigma, scale=np.exp(mu))

        prob_array = np.array(prob_exceed)
        if np.all(prob_array == 0) or np.all(prob_array == 1):
            print(f"⚠️ Skipping '{ds}' — flat probability distribution (all 0s or all 1s)")
            fragility_results[ds] = (np.nan, np.nan)
            continue

        try:
            popt, _ = curve_fit(lognorm_cdf, unique_IMs, prob_exceed, p0=[np.log(np.mean(unique_IMs)), 0.5])
            mu, sigma = popt
            fragility_results[ds] = (mu, sigma)
            print(f"✔️ Fitted '{ds}': mu = {mu:.3f}, sigma = {sigma:.3f}")
        except Exception as e:
            print(f"❌ Failed to fit for '{ds}': {e}")
            fragility_results[ds] = (np.nan, np.nan)

    plt.figure(figsize=(10, 6))
    x_vals = np.linspace(min(IMs), max(IMs), 300)
    for ds, (mu, sigma) in fragility_results.items():
        if np.isnan(mu): continue
        plt.plot(x_vals, lognorm.cdf(x_vals, s=sigma, scale=np.exp(mu)), label=ds)

    plt.ylim(0, 1)
    plt.xlabel("Spectral Acceleration Sa(T1) [g]", fontsize=12)
    plt.ylabel("Probability of Exceedance", fontsize=12)
    plt.title("Seismic Fragility Curves by Damage State", fontsize=14)
    plt.grid(True, linestyle='--', alpha=0.7)
    plt.legend(title="Damage State")
    plt.tight_layout()
    plt.savefig("fragility_curves_combined.png", dpi=300)
    plt.show()
    print("📈 Fragility plot saved as 'fragility_curves_combined.png'")

if __name__ == '__main__':
    run()

Summary

This fragility analysis tool allows engineers and researchers to:

  • Automate fragility curve generation from drift or response data
  • Visualize performance thresholds for multiple damage states
  • Incorporate results into risk models or decision-making tools

Need Help?

QuakeLogic Inc. provides advanced tools and consulting for:

  • Earthquake early warning systems
  • Structural health monitoring (SHM)
  • Fragility model development
  • Shake table testing and seismic instrumentation

📧 Reach out to us anytime: support@quakelogic.net