Technotonics Assignment

How to Control a Robot Using Python in ROS
TechnoTonics | 2026

Blog: https://technotonics.org/how-to-control-a-robot-using-python-in-ros
YouTube: https://youtu.be/donhdWpsaPc?si=PTlv5mG7KvSXQVy

Robotics is a fascinating field that combines engineering, computer science, and various technologies to create machines that assist, complement, or replace human activities. One of the most popular tools for developing robotic applications is the Robot Operating System (ROS). This open-source framework provides a collection of software libraries and tools to help you build robot applications. In this blog, we'll explore how to control a robot using Python in ROS, making it accessible even for those new to robotics.
Understanding ROS
Robot Operating System (ROS) is not an operating system in the conventional sense but rather a flexible framework for writing robot software. It provides services designed for a heterogeneous computer cluster such as hardware abstraction, low-level device control, implementation of commonly-used functionality, message-passing between processes, and package management.
Key Features of ROS
Modularity: ROS is structured as a set of cooperating processes (nodes) that communicate through message-passing.
Hardware Abstraction: It allows developers to create software that can be run on different hardware platforms.
Tool Support: ROS includes a range of tools to help developers debug and visualize the robot's operation.
Community: It has a large, active community which contributes to a vast repository of packages.
Setting Up Your Environment
Before diving into controlling a robot using Python in ROS, you need a proper setup:
Prerequisites
Operating System: ROS primarily supports Ubuntu. Ensure you have a compatible version installed.
Python: ROS supports both Python 2 and Python 3. Verify which version your ROS distribution supports.
ROS Installation: Follow the installation instructions for the specific version of ROS you plan to use.
Installing ROS
Set Up Your Sources List: Add the ROS package source to your system.
Set Up Your Keys: Ensure you can authenticate the packages.
Install ROS: Use the package manager to install ROS.
Initialize rosdep: This tool enables you to easily install system dependencies for source you want to compile and is required to run some core components in ROS.
Environment Setup: Ensure that your environment is correctly configured.
Writing Your First ROS Node in Python
A ROS node is a process that performs computation. In a robot control system, you might have nodes for sensor input, data processing, decision making, and actuator control.
Creating a ROS Workspace
Create a Catkin Workspace: Catkin is the ROS build system. To create a workspace:
mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/
catkin_make
Source Your Workspace: This sets up your environment to use the workspace.
source devel/setup.bash
Writing the Node
Create a Package: Packages in ROS are the main unit for organizing software. To create a package:
cd ~/catkin_ws/src
catkin_create_pkg my_robot std_msgs rospy roscpp
Write the Python Script: Navigate to your package's src directory and create a Python script.
cd ~/catkin_ws/src/my_robot/src
touch robot_controller.py
chmod +x robot_controller.py
Script Content: Write a simple script that publishes a message to a topic.
#!/usr/bin/env python

import rospy
from std_msgs.msg import String

def talker():
pub = rospy.Publisher('chatter', String, queue_size=10)
rospy.init_node('talker', anonymous=True)
rate = rospy.Rate(10) # 10hz
while not rospy.is_shutdown():
hello_str = "hello world %s" % rospy.get_time()
rospy.loginfo(hello_str)
pub.publish(hello_str)
rate.sleep()

if __name__ == '__main__':
try:
talker()
except rospy.ROSInterruptException:
pass
Build Your Package: Return to the root of your workspace and build your package.
cd ~/catkin_ws
catkin_make
Running the ROS Node
Start the ROS Master: Open a terminal and start the ROS master node.
roscore
Run Your Node: Open a new terminal, source your workspace, and run your node.
source ~/catkin_ws/devel/setup.bash
rosrun my_robot robot_controller.py
Monitor the Output: You should see your message being published to the topic.
Controlling a Robot
To control a robot, you'll need to interface with its hardware, usually through specific drivers or by publishing messages to topics that the robot subscribes to.
Understanding Topics and Services
Topics: Used for unidirectional communication, generally for data streaming.
Services: Used for request-reply communication, similar to function calls.
Example: Controlling a Robot's Movement
Suppose you have a robot with a differential drive system. You can control its movement by publishing velocity commands.
Create a New Python Script in your package's src directory:
cd ~/catkin_ws/src/my_robot/src
touch move_robot.py
chmod +x move_robot.py
Script Content: Write a script to publish velocity commands.
#!/usr/bin/env python

import rospy
from geometry_msgs.msg import Twist

def move():
pub = rospy.Publisher('/cmd_vel', Twist, queue_size=10)
rospy.init_node('move_robot', anonymous=True)
rate = rospy.Rate(10) # 10hz
vel_msg = Twist()

# Set linear velocity in x direction
vel_msg.linear.x = 0.5
vel_msg.linear.y = 0
vel_msg.linear.z = 0

# Set angular velocity in z direction
vel_msg.angular.x = 0
vel_msg.angular.y = 0
vel_msg.angular.z = 0.5

while not rospy.is_shutdown():
pub.publish(vel_msg)
rate.sleep()

if __name__ == '__main__':
try:
move()
except rospy.ROSInterruptException:
pass
Run the Node: Source your workspace and run the node to see your robot move.
Debugging and Visualization Tools
ROS offers several tools to help you debug and visualize your robot's operation:
rqt_graph: This tool provides a visual representation of the nodes and topics in your ROS system.
rviz: A 3D visualization tool for visualizing sensor data and state information from the robot.

Podcast: https://open.spotify.com/episode/0Fw2h9EQF1QkcjvC34wv4Q?si=og5IwG5pRniTThZVg19MgQ

Getting Started with ROS and Python: Build Your First Robot Node
TechnoTonics | 2026

Blog: https://technotonics.org/getting-started-with-ros-and-python-build-your-first-robot-node
YouTube: https://youtu.be/CdV0AM1Wkcw

The world of robotics is an exciting frontier where technology, creativity, and innovation converge. At the heart of this revolution is the Robot Operating System (ROS), an open-source framework that provides tools and libraries to help you build complex robots. Coupled with Python, a versatile and powerful programming language, ROS becomes an accessible platform for both beginners and experts to develop robot applications. This blog will guide you through the initial steps of setting up a ROS environment and creating your first robot node using Python.

Understanding ROS

What is ROS?

ROS stands for Robot Operating System. Despite its name, ROS is not an operating system but a flexible framework for writing robot software. It provides a collection of tools, libraries, and conventions that aim to simplify the task of creating complex and robust robot behavior across a wide variety of robotic platforms.

Why Use ROS?

ROS promotes code reuse and collaborative development, which means you can focus on building the unique aspects of your robot without having to start from scratch. Here are some key benefits:

Modularity: ROS allows you to build complex software architectures by connecting small, reusable programs called nodes.

Community: A large, active community contributes to a rich ecosystem of software packages.

Simulation: With ROS, you can simulate your robot in a virtual environment before deploying it to physical hardware.

Setting Up Your Development Environment

Prerequisites

Before diving into ROS, ensure your system meets the following prerequisites:

A computer running Ubuntu (ROS is primarily supported on Ubuntu, though there are ways to use it on other systems).

Basic understanding of Linux commands.

Familiarity with Python programming.

Installing ROS

Choose Your ROS Distribution: The ROS community regularly releases new distributions. As of October 2023, the latest stable version is ROS Noetic Ninjemys. However, check the ROS website for the latest updates.

Add the ROS Repository: Open a terminal and add the ROS repository to your system package sources:

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

Set Up Your Keys: To securely download ROS packages, you need to set up your keys:

sudo apt-key adv --keyserver 'hkp://keyserver.ubuntu.com:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654

Install ROS: Update your package index and install ROS with the following commands:

sudo apt update
sudo apt install ros-noetic-desktop-full

Initialize rosdep: This tool is essential for installing system dependencies for the packages you want to build:

sudo rosdep init
rosdep update

Environment Setup: Add ROS environment variables to your bash session:

echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

Install rosinstall: This command-line tool is essential for managing ROS packages:

sudo apt install python3-rosinstall python3-rosinstall-generator python3-wstool build-essential

Creating Your First ROS Package

Setting Up a Catkin Workspace

A Catkin workspace is the directory where you build and develop your ROS packages. Here’s how to set it up:

Create the Workspace Directory:

mkdir -p ~/catkin_ws/src

Initialize the Workspace:

cd ~/catkin_ws/
catkin_make

Source the Workspace:

source devel/setup.bash

Building Your First Node

Step 1: Create a ROS Package

Navigate to the src directory in your Catkin workspace:

cd ~/catkin_ws/src
catkin_create_pkg my_first_package std_msgs rospy roscpp

This command creates a package named my_first_package with dependencies on std_msgs, rospy, and roscpp.

Step 2: Write a Python Node

Navigate to the Package Directory:

cd ~/catkin_ws/src/my_first_package

Create a Scripts Directory:

mkdir scripts

Create a Python Script:

Inside the scripts directory, create a file called simple_node.py:

#!/usr/bin/env python3
import rospy
from std_msgs.msg import String

def talker():
pub = rospy.Publisher('chatter', String, queue_size=10)
rospy.init_node('talker', anonymous=True)
rate = rospy.Rate(1) # 1hz
while not rospy.is_shutdown():
hello_str = "hello world %s" % rospy.get_time()
rospy.loginfo(hello_str)
pub.publish(hello_str)
rate.sleep()

if __name__ == '__main__':
try:
talker()
except rospy.ROSInterruptException:
pass

Make the Script Executable:

Run the following command to make your script executable:

chmod +x scripts/simple_node.py

Step 3: Build Your Package

Navigate back to your Catkin workspace and build your package:

cd ~/catkin_ws
catkin_make

Step 4: Run Your Node

Source Your Workspace:

source devel/setup.bash

Run ROS Master:

Open a new terminal and run:

roscore

Run Your Node:

In another terminal, ensure your workspace is sourced, then run:

rosrun my_first_package simple_node.py

You should see messages being published to the chatter topic!

Understanding the Node

The Talker Node

The Python script you wrote is a simple "talker" node. It:

Initializes a ROS Node: The rospy.init_node() function initializes the node with a unique name. The anonymous=True parameter ensures the node has a unique name by appending random numbers to it.

Creates a Publisher: The rospy.Publisher() function creates a publisher object that will send String messages on the chatter topic.

Publishes Messages: Inside a loop, the node publishes a message and logs it to the console.

With this setup, you've successfully created and run a simple ROS node using Python!

Podcast: https://open.spotify.com/episode/6XrmkUsphn90IKK6ZMHbRs?si=oxaOROY6SSO8zMreC4yphQ

How ADINA Helps in Real-World Engineering Projects
TechnoTonics | 2026
Blog:https://technotonics.org/how-adina-helps-in-real-world-engineering-projects
YouTube: https://youtu.be/MVoq2onn4rA

In the realm of engineering, precision and accuracy are paramount. Engineers constantly seek tools that can enhance their ability to visualize, analyze, and solve complex problems. Among the numerous software solutions available, ADINA (Automatic Dynamic Incremental Nonlinear Analysis) stands out due to its robust capabilities and versatility. This blog explores how ADINA contributes to real-world engineering projects, highlighting its features, applications, and the benefits it offers to engineers across various industries.
Understanding ADINA
ADINA is a comprehensive software system for finite element analysis (FEA) and computational fluid dynamics (CFD). It is designed to provide engineers with advanced solutions for structural, fluid, and multiphysics problems. The software is renowned for its accuracy in simulating nonlinear and dynamic behaviors, making it an invaluable tool for engineers who tackle complex challenges in their projects.
Key Features of ADINA
Nonlinear Analysis: ADINA excels in analyzing nonlinear problems, including material nonlinearity, geometric nonlinearity, and boundary condition nonlinearity. This capability is crucial for accurately assessing how structures behave under various loads and stresses.
Dynamic Analysis: The software can simulate both linear and nonlinear dynamic behavior, allowing engineers to study how structures respond to time-dependent forces, such as earthquakes or machinery vibrations.
Multiphysics Capabilities: ADINA supports coupled analysis of different physical phenomena, enabling engineers to perform simulations that integrate structural, thermal, and fluid interactions.
User-Friendly Interface: Despite its advanced capabilities, ADINA offers a user-friendly interface that simplifies the setup and ex*****on of complex simulations.
High Accuracy: ADINA is known for its high precision in numerical simulations, which ensures that engineers can trust the results for critical decision-making.
Applications of ADINA in Engineering Projects
ADINA's versatility makes it applicable across numerous engineering disciplines. Below are some of the key areas where ADINA has made significant contributions:
Structural Engineering
In structural engineering, ADINA is used to analyze and design buildings, bridges, and other infrastructure. Engineers rely on the software to perform stress analysis, evaluate the structural integrity of materials, and predict failure points. ADINA's ability to simulate complex load conditions and material behaviors helps engineers ensure that structures can withstand real-world stresses.
Automotive Industry
The automotive industry benefits from ADINA's capabilities by using it to model crash simulations, optimize vehicle designs, and improve safety features. By simulating impact scenarios and analyzing materials' responses, engineers can enhance vehicle performance and passenger safety without extensive physical testing.
Aerospace Engineering
In aerospace, ADINA assists engineers in designing aircraft components, analyzing aerodynamic properties, and simulating fluid-structure interactions. The software's multiphysics capabilities are particularly valuable in this industry, where the interplay between thermal, structural, and fluid dynamics is critical.
Biomechanical Engineering
ADINA is also used in the field of biomechanics to analyze the behavior of biological structures. Engineers and researchers use it to simulate the mechanical behavior of bones, tissues, and implants, leading to better medical devices and treatment methods.
Civil Engineering
For civil engineers, ADINA aids in the design and analysis of dams, tunnels, and other infrastructure projects. The software's dynamic analysis capabilities are vital for assessing how structures will respond to natural forces like earthquakes and floods.
Benefits of Using ADINA in Engineering Projects
Enhanced Accuracy and Precision
One of the primary benefits of using ADINA is its unparalleled accuracy in simulations. The software's ability to handle complex, nonlinear problems ensures that engineers can rely on the results for making informed decisions. This precision is crucial in industries where even minor errors can lead to significant consequences.
Cost and Time Efficiency
By enabling engineers to perform detailed simulations, ADINA reduces the need for extensive physical prototyping and testing. This capability not only saves time but also reduces costs associated with material and labor. Engineers can test multiple scenarios virtually, optimizing designs before any physical implementation.
Improved Safety and Reliability
Safety is a top priority in engineering projects, and ADINA contributes to enhanced safety by allowing engineers to predict potential failure modes and assess structural integrity under various conditions. This foresight enables engineers to design safer structures and systems, thereby reducing the risk of accidents.
Versatility and Flexibility
ADINA's multiphysics capabilities and broad application range make it a versatile tool for engineers. Whether dealing with structural, thermal, or fluid dynamics problems, engineers can use a single platform to address diverse challenges, streamlining the workflow and improving collaboration among teams.
Innovation and Optimization
With ADINA, engineers can explore innovative designs and optimize existing systems. The software's advanced simulation capabilities allow for experimentation with new materials, configurations, and load conditions, leading to breakthroughs in engineering design and performance.
Challenges and Considerations
While ADINA offers numerous advantages, there are challenges and considerations that engineers should be aware of:
Learning Curve: Despite its user-friendly interface, mastering ADINA's full capabilities may require a significant investment of time and training.
Computational Resources: Running large, complex simulations can be resource-intensive, necessitating powerful hardware and computational infrastructure.
Cost: Acquiring and maintaining ADINA licenses can be costly, particularly for smaller firms or individual users.
Conclusion
ADINA is a powerful tool that has revolutionized the way engineers approach complex problems in various industries. Its ability to provide accurate simulations, coupled with its versatility across multiple disciplines, makes it an indispensable resource for engineering projects. While there are challenges to consider, the benefits of using ADINA far outweigh the drawbacks, paving the way for safer, more efficient, and innovative engineering solutions.

Podcast: https://open.spotify.com/episode/7ktaknv4OYEfD4et1cMjYN?si=2KlBurC8RKKU30QchRbTzQ

Top 10 Features of ADINA That Make It Powerful for Structural Analysis
TechnoTonics | 2026
Blog: https://technotonics.org/top-10-features-of-adina-that-make-it-powerful-for-structural-analysis
YouTube: https://youtu.be/ktmZg42sjhI

In the world of engineering and structural analysis, having a robust and versatile software tool is crucial for achieving accurate and reliable results. ADINA (Automatic Dynamic Incremental Nonlinear Analysis) is one such tool that has been widely acclaimed for its powerful capabilities in the field of structural analysis. With its advanced features and user-friendly interface, ADINA stands out as a leading choice for engineers and researchers alike. In this blog, we will delve into the top 10 features that make ADINA a formidable tool for structural analysis.
1. Comprehensive Finite Element Analysis (FEA)
At the heart of ADINA’s capabilities is its comprehensive finite element analysis. ADINA supports a wide range of finite element types, including beams, shells, solids, and contact elements. This versatility allows for the modeling of complex structures with a high degree of accuracy. The software is equipped to handle both linear and nonlinear analyses, accommodating a variety of material behaviors and geometrical configurations.
2. Advanced Nonlinear Capabilities
One of ADINA’s standout features is its advanced nonlinear analysis capabilities. Structural analysis often involves dealing with nonlinearities, whether due to material properties, large deformations, or contact phenomena. ADINA excels in handling these complexities with precision. Its robust algorithms ensure that engineers can accurately simulate real-world conditions, making it an invaluable tool for predicting the behavior of structures under various load conditions.
3. Dynamic Analysis
ADINA offers comprehensive dynamic analysis features, including modal analysis, time history analysis, and frequency response analysis. This feature set is crucial for evaluating the effects of dynamic loads, such as earthquakes, wind, and machinery vibrations, on structures. By understanding how structures respond to dynamic forces, engineers can design more resilient and safer buildings and infrastructure.
4. Coupled Multi-Physics Analysis
In today’s interconnected world, understanding the interactions between different physical phenomena is essential. ADINA provides coupled multi-physics analysis capabilities, allowing for the simultaneous simulation of structural, thermal, fluid, and electromagnetic phenomena. This integrated approach is particularly beneficial in industries like aerospace and automotive, where complex interactions can significantly impact performance and safety.
5. Robust Contact Analysis
Contact analysis is a critical aspect of structural analysis, especially in scenarios involving interacting components. ADINA’s robust contact analysis capabilities enable the accurate modeling of contact mechanics, including friction and wear. This feature is invaluable for simulating the behavior of assemblies and ensuring the structural integrity of components under load.
6. User-Friendly Interface
While ADINA is known for its powerful analysis capabilities, it also boasts a user-friendly interface that simplifies the modeling process. The intuitive graphical interface allows users to easily define geometry, assign material properties, and apply boundary conditions. This ease of use reduces the learning curve for new users and enhances productivity for experienced analysts.
7. Comprehensive Material Models
ADINA offers a wide array of material models to accommodate different engineering needs. From linear elastic to complex viscoelastic and plastic models, ADINA provides the flexibility to accurately represent the behavior of various materials. This feature is particularly useful in industries like construction and manufacturing, where materials can exhibit unique and complex responses under load.
8. High-Performance Solvers
When it comes to computational efficiency, ADINA stands out with its high-performance solvers. These solvers are optimized for speed and accuracy, enabling the analysis of large-scale models in a reasonable timeframe. This capability is crucial for meeting project deadlines and conducting detailed analyses without compromising on precision.
9. Extensive Post-Processing Tools
After completing an analysis, engineers need to interpret the results effectively. ADINA offers extensive post-processing tools that provide detailed insights into the structural behavior of models. With features like contour plots, vector plots, and animations, users can visualize stress distributions, deformations, and more, facilitating a deeper understanding of the analysis outcomes.
10. Strong Support and Documentation
Last but not least, ADINA is backed by strong support and comprehensive documentation. The availability of technical support and detailed manuals ensures that users can quickly resolve any issues and make the most of the software’s capabilities. This support network is a testament to ADINA’s commitment to customer satisfaction and continuous improvement.

Podcast: https://open.spotify.com/episode/4AuM9uIj29RXGfu1N3evql?si=6evwBJrHRcihND4DFIVG0w

Getting Started with ADINA: A Beginner’s Guide to Finite Element Analysis
Technotonics | 2026

Blog: https://technotonics.org/getting-started-with-adina-a-beginner-s-guide-to-finite-element-analysis
YouTube: https://youtu.be/C1f5SYZcmeA

Finite Element Analysis (FEA) is a powerful computational tool used to predict how structures and systems will react to external forces, vibrations, heat, and other physical effects. Among the various software available for FEA, ADINA (Automatic Dynamic Incremental Nonlinear Analysis) stands out due to its robustness and capability to handle complex problems. In this guide, we will explore the basics of ADINA and provide a step-by-step approach to getting started with this invaluable tool.

Understanding Finite Element Analysis

Before diving into ADINA, it’s essential to grasp the basic concept of Finite Element Analysis. FEA is a numerical method used to approximate solutions to complex engineering problems. It involves breaking down a large system into smaller, manageable finite elements. The behavior of these elements is described by differential equations, which are then solved to understand the overall behavior of the system.

Key Concepts in FEA

Mesh Generation: The process of dividing a structure into finite elements.

Boundary Conditions: Constraints applied to the model to simulate real-world conditions.

Loads and Forces: External actions applied to the model, such as pressure, temperature, or physical forces.

Solution: The process of solving the equations to find displacements, stresses, and other responses.

Post-Processing: Analyzing and visualizing results for interpretation.

What is ADINA?

ADINA is a comprehensive FEA software that offers capabilities for both linear and nonlinear analysis. It is used across various industries, including civil engineering, automotive, aerospace, and biomechanics, to simulate structural, fluid, heat transfer, and electromagnetic phenomena. ADINA is renowned for its accuracy and ability to handle complex geometries and material behaviors.

Features of ADINA

Multiphysics Capabilities: Supports coupled analyses such as fluid-structure interaction (FSI) and thermo-mechanical simulations.
Advanced Material Models: Includes models for plasticity, viscoelasticity, and hyperelasticity.

Robust Solver: Efficient solvers for linear and nonlinear problems.
User-Friendly Interface: Intuitive GUI for setting up models and visualizing results.
Customization: Supports custom scripting for advanced modeling needs.
Getting Started with ADINA

Step 1: Installation and Setup
To begin using ADINA, you need to download and install the software. ADINA offers a trial version, which is ideal for beginners. Follow these steps for installation:
Download: Visit the ADINA website and download the appropriate version for your operating system.
Install: Run the installer and follow the on-screen instructions. Ensure you have administrative privileges on your computer.
License: Activate the software using the provided license key or request a trial license.
Setup: Configure any necessary settings such as preferred units and default directories.

Step 2: Familiarizing with the Interface

Once installed, launch the ADINA software to familiarize yourself with the interface:
Menu Bar: Contains options for file management, model setup, analysis, and help.
Toolbars: Quick access to common functions like creating geometry, defining materials, and applying loads.
Model Tree: Displays the hierarchical structure of your model components.
Graphics Window: Visualizes the model and results.
Output Window: Shows messages, errors, and analysis progress.

Step 3: Creating a Simple Model

To illustrate the basic workflow in ADINA, let's create a simple model of a beam under load:
Geometry Creation: Use the geometry tools to draw the beam. Define its dimensions and shape.
Material Definition: Select a material from the database or define a new one. Specify properties like Young’s modulus and Poisson’s ratio.
Mesh Generation: Divide the beam into finite elements. Use the automatic meshing feature for simplicity.
Applying Boundary Conditions: Fix one end of the beam to simulate a cantilever condition.
Loading: Apply a force at the free end of the beam.

Step 4: Running the Analysis
With the model set up, proceed to run the analysis:
Analysis Type: Choose the appropriate analysis type (e.g., static, dynamic, or thermal).
Solver Settings: Configure solver preferences if necessary.
Run: Initiate the analysis and monitor progress in the output window.

Step 5: Post-Processing Results
After the analysis completes, it’s time to interpret the results:
Result Visualization: Use the post-processing tools to view displacement, stress distribution, and other results.
Graphs and Plots: Generate graphs to analyze specific results like deflection curves or stress-strain plots.
Report Generation: Compile findings into a report format for documentation or presentation purposes.
Tips for Effective Use of ADINA
Start Simple: Begin with simple models to understand the workflow before tackling complex simulations.
Utilize Tutorials: ADINA offers comprehensive tutorials and documentation. Use these resources to enhance your understanding.
Experiment with Settings: Explore different solver settings and mesh refinements to see their impact on results.
Seek Community Advice: Engage with the ADINA user community for tips, best practices, and troubleshooting advice.

Podcast: https://open.spotify.com/episode/0VnNfUSESEJ3bwdX18E1dF?si=3SHOC27eQoKSrLWOR2rh_w