Embedded Linux Development

HRDC Reg. No: 10001513392

Duration: 2 days (14 hours)

Course Overview

This 2-day intensive course provides an in-depth understanding of embedded systems development using C, C++, Linux system programming, kernel programming, and device driver development. Participants will engage in hands-on exercises covering multithreading, interprocess communication (IPC), debugging, and real-world device driver implementation.

Who Should Attend?

• Software Engineers & Developers transitioning into embedded systems
• Computer Science Graduates seeking Linux & embedded development expertise
• IT Professionals specializing in C/C++ programming and device drivers

Why Choose This Course?

This HRDC-claimable course (HRDC Reg. No: 10001513392) offers hands-on experience in real-world embedded programming, system debugging, and device driver development, essential for automotive, consumer electronics, IoT, and industrial automation applications.

Learning Outcomes

By the end of this course, participants will be able to:

Master pointers, data structures, and function pointers for efficient programming
Develop object-oriented C++ applications using modern standards (C++11, C++14)
Build expertise in Linux system programming (file systems, IPC, threading)
Implement Linux kernel modules & device drivers
Utilize GIT, Jenkins, GDB, and Valgrind for debugging and configuration management
Gain knowledge of communication protocols (GPIO, SPI, I2C, UART, CAN)
Apply concepts through hands-on labs & a mini-project

Prerequisites

• Basic programming knowledge (C/C++)
• Familiarity with operating systems
• Interest in embedded systems & Linux environments

Target Industry

• Automotive
• Consumer Electronics
• Telecommunications
• Internet of Things (IoT)
• Industrial Automation

Lab Setup

Hardware Requirements

• Development Boards (e.g., Raspberry Pi)
• Linux-based system (Ubuntu, RHEL8 preferred)
• Minimum 8GB RAM & quad-core CPU for virtualized environments

Software Requirements

• GNU Toolchain (gcc, gdb, binutils, make)
• Linux Kernel Source Code (5.x or later)
• IDE/Text Editors (Vim, Nano, or VS Code)
• Debugging Tools (Valgrind, GDB, Perf, SystemTap)
• Version Control Tools (GIT, GitHub)

Teaching Methodology

Instructor-led Lectures – Core concepts explained with real-world examples
Hands-on Lab Exercises – Step-by-step programming & debugging tasks
Live Code Demonstrations – Practical debugging and troubleshooting sessions
Collaborative Learning – Mini-project development & peer discussions
Assessments & Feedback – Real-time problem-solving & exit tests

Embedded Linux Development

HRDC Reg. No: 10001509705

Duration: 4 days (28 hours)

Course Overview

This 4-day intensive course provides an in-depth understanding of security in Embedded Linux systems. The training focuses on secure booting, kernel hardening, root filesystem security, data encryption, Trusted Execution Environments (TEE), and SELinux (Security-Enhanced Linux). Participants will implement security features through hands-on exercises, ensuring practical application of key security mechanisms.

Who Should Attend?

• Embedded Linux Developers
• System Security Engineers
• IoT and Edge Computing Professionals
• Security Researchers & Analysts

Why Choose This Course?

This HRDC-claimable course (HRDC Reg. No: 10001509705) offers real-world training on securing bootloaders, kernels, root filesystems, and applications in Embedded Linux, ensuring compliance with modern security standards.

Learning Outcomes

By the end of this course, participants will be able to:

Implement Secure Boot and verify the authenticity of system components
Ensure bootloader and kernel integrity
Configure Trusted Boot and Trusted Execution Environments (TEE)
Harden the Linux kernel & root filesystem against security threats
Implement data encryption techniques (Full Disk Encryption, File-based Encryption)
Deploy SELinux security policies for system protection

Prerequisites

• Knowledge of C programming
• Comfort with Linux user space & basic shell scripting

Teaching Methodology

Instructor-led Lectures – Explanation of security principles in Embedded Linux
Hands-on Lab Exercises – Practical implementation of secure boot, encryption, and SELinux
Case Studies & Problem Solving – Real-world security threats & mitigation strategies
Assessments & Feedback – Evaluating understanding through projects and quizzes

Embedded Linux Development

HRDC Reg. No: 10001406976

Duration: 35 hours (5 days)

Course Overview

This 5-day intensive course provides a deep insight into operating system (OS) concepts, covering key topics such as process management, multithreading, synchronization, interprocess communication (IPC), and memory management. Participants will gain hands-on experience in designing and developing multitasking applications while efficiently managing system resources.

Who Should Attend?

• Software Developers & Engineers working on OS-based applications
• Embedded Systems Developers dealing with real-time OS
• System Administrators & IT Professionals handling multi-threaded applications
• Students & Professionals interested in advanced OS concepts

Why Choose This Course?

This HRDC-claimable course (HRDC Reg. No: 10001406976) provides real-world hands-on training on OS fundamentals, process management, task scheduling, memory management, concurrency control, and IPC mechanisms essential for modern computing.

Learning Outcomes

By the end of this course, participants will be able to:

Understand fundamental OS concepts and their applications
Work with multi-threaded and multi-process environments
Implement task scheduling and synchronization mechanisms
Manage memory efficiently in Linux & FreeRTOS
Design inter-process communication (IPC) mechanisms for data exchange
Apply concurrency management techniques to avoid deadlocks and race conditions

Prerequisites

• Knowledge of C programming

Lab Setup

• FreeRTOS Simulator for Windows
• Windows Subsystem for Linux (WSL)

Teaching Methodology

Instructor-led Theoretical Sessions – In-depth OS concepts explained with real-world examples
Hands-on Lab Exercises – Practical implementation of OS functionalities
Case Studies & Problem Solving – Application of OS techniques in different scenarios
Assessments & Feedback – Evaluating participant understanding through projects and quizzes

Embedded Linux Development

HRDC Reg. No: 10001441700
Duration: 35 hours (5 days)

Course Overview:

This 5-day course offers in-depth training in Linux driver development for embedded systems, focusing on I2C and SPI drivers. It covers low-level device drivers, hardware register access, and device tree integration. The course also emphasizes platform drivers and integrating drivers with the Linux kernel framework.

Learning Objectives:

By the end of the course, participants will be able to:

• Develop low-level drivers from scratch by accessing hardware registers.
• Understand and apply the Linux driver design philosophy.
• Integrate drivers into the Linux framework using Platform Drivers and Device Tree Blob (DTB).
• Work with interrupt handling and bottom halves.
• Implement I2C and SPI drivers within the Linux kernel.

Target Audience:

• Embedded Systems Engineers
• Device Driver Developers
• Linux Kernel Developers
• Hardware Engineers

Prerequisites:

• Proficiency in C programming.
• Familiarity with Linux systems and basic character drivers.
• Knowledge of Mutex, Semaphore, Wait Queues, and Interrupt Management.

Teaching Methodology:

• Instructor-led theory sessions.
• Hands-on labs with coding assignments.
• Real-world hardware demonstrations.
• Group discussions and Q&A sessions.

Embedded Linux Development

HRDC Reg. No: 10001441700
Duration: 35 hours (5 days)

Course Overview

This 5-day intensive training program equips participants with the knowledge and hands-on experience to develop Linux device drivers. Covering both theoretical foundations and practical lab exercises, the course delves into kernel architecture, driver frameworks, character drivers, and hardware interaction.

Who Should Attend?

• Embedded Systems Developers
• Linux Kernel Programmers
• Device Driver Developers
• System Administrators & DevOps Engineers working with Linux systems

Why Choose This Course?

This HRDC-claimable course (HRDC Reg. No: 10001441700) offers real-world hands-on training on Linux kernel and driver development, essential for those working with embedded systems and hardware-software integration.

Learning Outcomes

By the end of this course, participants will be able to:

Understand the Linux kernel architecture and device driver model
Develop character device drivers and interact with hardware peripherals
Work with kernel modules, memory management, and I/O operations
Debug and troubleshoot driver issues using kernel logs & debugging tools
Implement interrupt handling and synchronization mechanisms
Write secure, efficient, and maintainable Linux drivers

Prerequisites

• Experience with C programming
• Basic knowledge of Linux command line and shell scripting
• Familiarity with system programming concepts

Teaching Methodology

Instructor-led Theoretical Sessions – Explaining Linux kernel & driver internals
Hands-on Lab Exercises – Practical implementation of device drivers
Code Debugging & Analysis – Kernel logs, debugging tools, and real-time testing
Case Studies – Real-world driver development scenarios
Assessments & Feedback – Pre- and post-assessment tests to track learning progress

Embedded Linux Development

HRDC Reg. No: 10001242330
Duration: 14 hours (2 days)

Course Overview:

This 2-day course provides a comprehensive introduction to C programming with a focus on embedded systems development and GDB debugging techniques. The course combines theoretical concepts with hands-on labs, equipping participants with practical skills in C programming, memory handling, and debugging strategies for embedded systems.

Learning Outcomes:

By the end of the course, participants will be able to:

1. Demonstrate a solid understanding of C programming fundamentals.
2. Apply advanced C concepts like pointers, bit manipulation, and preprocessors.
3. Implement C functions and modular code structures.
4. Utilize GDB for debugging embedded systems effectively.
5. Identify and resolve common errors using breakpoints and watchpoints.
6. Analyze memory structures, including stack, heap, and data segments.

Prerequisites:

• Basic programming experience.
• Familiarity with C concepts (data types, control structures).
• Basic knowledge of computer architecture (helpful but not mandatory).

Teaching Methodology:

• Lectures: Concept presentations and theory breakdowns.
• Hands-On Labs: Guided exercises for practical application.
• Q&A Sessions: Interactive discussions and problem-solving.
• Real-World Projects: Application-focused programming challenges.

Embedded Linux Development

HRDC Reg. No: 10001465579
Duration: 14 hours (2 days)

Course Description

This 2-day course offers a hands-on approach to Linux kernel programming for embedded systems. It covers essential concepts and practical skills required for developing kernel modules, device drivers, and customizing the Linux kernel for embedded platforms.

Learning Outcomes

By the end of the course, participants will be able to:

• Understand the Linux kernel architecture and its components.
• Write and compile Linux kernel modules.
• Develop and deploy device drivers for embedded hardware.
• Integrate kernel modules with user-space applications.
• Debug and optimize embedded kernel code.
• Work with cross-compilation toolchains for embedded development.
• Manage interrupt handling, memory management, and synchronization in the kernel.

Prerequisites

• Basic knowledge of the Linux operating system.
• Experience in C programming.
• Familiarity with embedded systems development and tools.

Lab Setup Requirements

• Embedded Linux development boards (e.g., Raspberry Pi, BeagleBone).
• Cross-compilation tools (GCC for ARM, Yocto/Buildroot).
• Linux host machine for development (Ubuntu preferred).
• Serial communication tools for debugging (e.g., minicom, screen).
• Debugging tools (GDB, KGDB).

Teaching Methodology

• Instructor-led lectures.
• Hands-on lab exercises.
• Case studies and real-world examples.
• Interactive Q&A sessions.

Target Audience

• Embedded Systems Engineers
• Linux Developers focusing on kernel-level programming.
• Device Driver Developers

Target Industries

• Embedded Systems & IoT Development
• Consumer Electronics
• Automotive Industry
• Telecommunications

Embedded Linux Development

HRDC Reg. No: 10001488664
Duration: 14 hours (2 days)

Course Overview

This 2-day masterclass offers an in-depth understanding of the boot-up process and customization techniques for Embedded Linux Systems, focusing on the BeagleBone Black (BBB) platform. The course combines theory with hands-on labs, enabling participants to:

• Analyze and optimize the Linux boot-up sequence from bootloaders to user space.
• Recover and restore bricked BeagleBone Black devices.
• Customize and enhance U-Boot, kernel, and platform features.
• Implement boot-up optimization techniques for faster performance.

Who Should Attend

Ideal for:

• Embedded System Engineers mastering boot-up optimization.
• Firmware Developers working with U-Boot and kernel customization.
• System Integrators working with BeagleBone Black or similar platforms.
• Intermediate to Advanced Linux Users with embedded systems experience.

Targeted Industries:

• Embedded Systems and IoT
• Consumer Electronics
• Automotive and Industrial Automation
• Telecommunications and Aerospace
• Healthcare and Medical Devices

Learning Outcomes

By the end of the course, participants will:

• Master boot-up flow concepts in Embedded Linux.
• Recover and troubleshoot bricked devices.
• Customize U-Boot and the Linux kernel.
• Implement boot-up optimization techniques.
• Work with device trees and root filesystems.

Prerequisites

• Basic knowledge of Linux system administration.
• Familiarity with C programming and device drivers.
• Experience with embedded systems (recommended).

Lab Setup Requirements

• Hardware:
  • BeagleBone Black (BBB) board
  • MicroSD Card (min. 8GB)
  • USB-to-TTL Serial Cable
  • Power supply for BBB
  • SD card reader/writer
• Software:
  • Linux Workstation/VM with GCC, Make, ARM Toolchain
  • U-Boot, Kernel Source, RootFS Images
  • NFS server for network booting
• Network Setup:
  • Ethernet connection for BBB

Embedded Linux Development

HRDC Reg. No: 10001240991
Duration: 35 hours (5 days)

Course Overview

This 5-day course provides an in-depth exploration of Embedded Linux Kernel Internals in a hardware-specific context. It covers key Linux subsystems, device driver frameworks, synchronization mechanisms, DMA engine, and debugging tools for effective Linux driver development.

Learning Objectives

• Understand Linux kernel internals for embedded systems.
• Configure and build the kernel, root filesystem, and device tree.
• Explore boot initialization and board bring-up.
• Develop and debug character drivers and platform drivers.
• Implement synchronization mechanisms and interrupt handling.
• Utilize the Linux DMA engine for efficient data handling.
• Apply debugging techniques in the Linux kernel.

Who Should Attend

• Embedded Software Engineers
• Device Driver Developers
• Linux Kernel Developers
• System Architects

Prerequisites

• Proficiency in C/C++ programming.
• Basic knowledge of Linux systems and device drivers.

Embedded Linux Development

HRDC Reg. No: 10001443631
Duration: 21 hours (3 days)

Course Overview:

The Linux Audio Drivers course offers deep insights into Embedded Linux Audio Driver Development. It starts with digital audio basics, explaining the ALSA (Advanced Linux Sound Architecture) framework and progresses into ASoC (ALSA System on Chip) drivers and Codec integration. Hands-on labs accompany each topic for practical understanding.

Learning Objectives:

Upon course completion, participants will:

• Develop proficiency with ALSA applications.
• Gain in-depth knowledge of the ALSA driver stack.
• Understand buffer management within ALSA.
• Integrate drivers using the ASoC framework.
• Implement and test Codec drivers.

Prerequisites:

• Knowledge of C programming.
• Familiarity with Linux systems.
• Understanding of Kernel constructs (Mutex, Semaphore, Wait Queues, Interrupt Management).

Target Audience:

• Professionals seeking expertise in Linux device drivers.
• Embedded system engineers and audio driver developers.

Teaching Methodology:

• Instructor-led sessions.
• Hands-on labs for practical application.
• Assignments for each theoretical module.

Embedded Linux Development

HRDC Reg. No: 10001468747
Duration: 21 hours (3 days)

Course Overview

This 3-day course provides in-depth knowledge of Linux Inter-Integrated Circuit (I2C) drivers. Participants will learn to develop, debug, and integrate I2C drivers into the Linux kernel, including communication protocols and device tree configurations. Hands-on labs and real-world examples will ensure practical skills in I2C driver development.

Who Should Attend

Ideal for:

• Embedded Systems Engineers
• Linux Kernel Developers
• Device Driver Engineers
• System Architects

Learning Outcomes

Upon completing this course, participants will be able to:

• Understand the I2C protocol and communication principles.
• Write and integrate I2C drivers into the Linux kernel.
• Use the Linux I2C subsystem APIs for device communication.
• Debug and troubleshoot I2C driver issues.
• Implement best practices for I2C driver development.

Prerequisites

• Basic knowledge of C programming.
• Familiarity with Linux kernel internals.
• Prior experience with embedded systems and device drivers (recommended).

Lab Setup

• Ubuntu/Debian-based Linux distribution.
• Linux kernel source code (latest stable version).
• Cross-compilation toolchain for embedded development.
• I2C hardware modules (e.g., temperature sensors, EEPROM).
• Debugging tools: GDB, dmesg, i2c-tools.

Teaching Methodology

• Instructor-led lectures for theoretical concepts.
• Hands-on labs for practical skill application.
• Case studies for real-world implementations.
• Quizzes and practical assessments

Embedded Linux Development

HRDC Reg. No: 10001468112
Duration: 21 hours (3 days)

Course Overview

This 3-day course provides in-depth training on Linux kernel debugging techniques, tools, and strategies. It covers essential methods for diagnosing and resolving issues in the Linux kernel, such as crashes, deadlocks, performance bottlenecks, and race conditions. Hands-on labs and real-world scenarios ensure participants gain practical expertise in kernel debugging.

Who Should Attend

Ideal for:

• Kernel Developers
• System Programmers
• Linux System Administrators
• Embedded Systems Engineers

Learning Outcomes

Upon completing this course, participants will be able to:

1. Understand Linux kernel architecture and debugging challenges.
2. Use tools like GDB, KGDB, ftrace, perf, and kdump.
3. Analyze kernel crashes, stack traces, and panic messages.
4. Debug deadlocks, race conditions, and performance bottlenecks.
5. Troubleshoot synchronization and memory management issues.

Prerequisites

• Basic understanding of Linux operating systems.
• Familiarity with C programming.
• Knowledge of Linux kernel development (recommended).

Lab Setup

• Linux system with GDB, KGDB, kdump, ftrace, and perf installed.
• Virtual machines or physical setups for kernel debugging.
• Access to Linux kernel source code.
• Remote debugging setup for KGDB configurations.

Teaching Methodology

• Instructor-led presentations with demonstrations.
• Hands-on labs and practical case studies.
• Group discussions and Q&A sessions.
• Continuous assessments through quizzes and debugging tasks.

Embedded Linux Development

HRDC Reg. No: 10001468097
Duration: 21 hours (3 days)

Course Overview

This 3-day course provides comprehensive training on developing Linux device drivers for SPI (Serial Peripheral Interface) and UART (Universal Asynchronous Receiver-Transmitter) communication protocols. Participants will gain hands-on experience with kernel programming, hardware interfacing, and driver debugging for embedded systems.

Who Should Attend

Ideal for:

• Embedded Software Engineers
• System Developers
• Linux Kernel Developers
• Engineers working with SPI and UART communication protocols

Learning Outcomes

Upon completing this course, participants will be able to:

1. Understand SPI and UART communication protocols and their applications.
2. Develop and implement SPI and UART drivers in the Linux kernel.
3. Configure device trees for hardware interfacing.
4. Troubleshoot and debug SPI and UART drivers effectively.
5. Write and compile Linux kernel modules for embedded systems.

Prerequisites

• Basic C programming knowledge.
• Familiarity with Linux command-line tools.
• Prior experience with Linux kernel internals (recommended).

Lab Setup

• Linux development environment (Ubuntu/CentOS or similar).
• Development boards (Raspberry Pi, BeagleBone, or similar).
• Cross-compiler for ARM/Embedded architectures.
• Necessary cables and SPI/UART modules for testing.

Teaching Methodology

• Instructor-led presentations and discussions.
• Hands-on labs and real-time debugging.
• Interactive Q&A sessions.
• Code reviews and troubleshooting exercises.

Embedded Linux Development

HRDC Reg. No: 10001306393
Duration: 35 hours (5 days)

Course Overview:

The Linux System Programming Certificate Training equips participants with the essential skills and knowledge required to develop software applications on the Linux operating system. It covers key concepts such as process management, file handling, inter-process communication (IPC), and system calls, ensuring a comprehensive foundation in Linux system programming.

Who Should Attend:

• Software Developers aiming to enhance Linux system programming skills.
• System Administrators seeking a deeper understanding of Linux internals.
• Computer Science Graduates specializing in system-level programming.
• Embedded Systems Developers working with Linux-based platforms.
• DevOps Engineers managing Linux-based infrastructures.

Why Learn Linux System Programming?

• Ubiquity: Powering servers, supercomputers, and IoT devices.
• Open Source Integration: Apache, MariaDB, Python.
• Career Enhancement: High demand for Linux expertise in IT sectors.
• Automation Skills: Bash scripting for task automation.
• Technical Mastery: Critical for system programming and administration.

Key Hands-On Labs:

• Configuring file permissions and filters.
• Writing shell scripts for task automation.
• Creating and managing processes using fork(), exec(), and wait().
• Implementing IPC mechanisms like pipes, message queues, and shared memory.
• Debugging C programs using gdb and gcov.

Assessment and Certification:

• Quizzes and Hands-on Projects for each module.
• Final Project: Develop a multi-threaded system utility using Linux system calls.
• Certificate of Completion for successful participants.

Embedded Linux Development

HRDC Reg. No: 10001469192
Course Duration: 21 hours (3 Days)

Course Overview

This intensive course provides an in-depth exploration of Linux user space internals, focusing on system calls, memory management, process and thread handling, inter-process communication (IPC), and debugging techniques. Participants will gain hands-on experience through labs and practical examples to solidify their understanding of how user space interacts with the Linux kernel.

Who Should Attend

• Software developers and engineers interested in Linux system programming.
• IT professionals expanding their knowledge of Linux internals.
• Linux system administrators seeking a deeper understanding of user space mechanisms.

Target Industries:

• IT and Software Development
• Cloud Computing
• Embedded Systems Development
• System and Network Administration

Why Choose This Course?

• Hands-on labs and interactive discussions.
• Real-world scenarios for practical skill-building.
• Expert instructors with extensive Linux experience.

Learning Outcomes

Upon completion, participants will be able to:

• Comprehend Linux user space architecture and components.
• Utilize system calls to interact with the Linux kernel.
• Manage processes, threads, and signals in user space.
• Apply memory management techniques in user space.
• Implement IPC mechanisms for effective process communication.
• Use debugging and performance optimization tools effectively.

Prerequisites

• Basic knowledge of Linux and standard commands.
• Familiarity with C programming.
• Understanding of fundamental operating system concepts.

Lab Setup

• Linux environment (Ubuntu/CentOS).
• System utilities: strace, gdb, lsof.
• IDE or text editor (VSCode, Vim, Nano).
• C compiler (GCC) and build tools.

Teaching Methodology

• Lectures: Core concepts introduced with slides and discussions.
• Hands-on Labs: Practical coding exercises to reinforce theoretical concepts.
• Group Discussions: Peer interaction for idea exchange and clarity.
• Q&A Sessions: Dedicated slots for clarifying doubts.
• Assignments: Coding challenges and tasks for self-practice.

Embedded Linux Development

HRDC Reg. No: 10001478272
Duration: 14 hours (2 days)

Course Overview:

This 2-day course offers a comprehensive understanding of Linux user space internals with a focus on process management, threads, synchronization, and inter-process communication (IPC). Participants will gain hands-on skills in developing multi-threaded and multi-processing applications, essential for efficient system resource management.

Learning Outcomes:

By the end of the course, participants will be able to:

• Understand Linux system calls and user space architecture.
• Manage and control processes and threads effectively.
• Implement synchronization mechanisms using mutexes and semaphores.
• Apply inter-process communication (IPC) methods such as pipes, FIFOs, and shared memory.
• Develop multi-threaded applications in a Linux environment.

Prerequisites:

• Knowledge of C programming.
• Comfortable working in a Linux environment.

Target Audience:

• Professionals and students aiming to design and develop Linux-based applications.
• Engineers working in multi-threaded and multi-processing environments.

Target Industries:

• Telecommunications
• Embedded Systems
• Software Development
• Cloud Computing & Data Centers
• Financial Services
• Automotive
• Cybersecurity & Defense
• Healthcare & Medical Devices
• High-Performance Computing (HPC)
• Aerospace and Defense Systems

Teaching Methodologies:

• Instructor-led sessions
• Hands-on programming exercises
• Real-world case studies
• Group discussions and Q&A
• Code walkthroughs and debugging
• Assignments and mini-projects
• Final project implementation and review

Embedded Linux Development

HRDC Reg. No: 10001189424
Duration: 10.5 hours (1.5 days)

Course Overview:

This 1.5-day course provides a comprehensive understanding of SELinux (Security-Enhanced Linux) with a focus on its integration into Android OS. It covers both theoretical concepts and hands-on practical exercises to help participants master SELinux policies, tools, and debugging strategies.

Who Should Attend:

Ideal for:

• Android Platform Developers
• Security Engineers
• Embedded Systems Developers
• Professionals modifying Android OS source code

Prerequisites:

• Familiarity with Android OS architecture and its components.

Learning Outcomes:

By the end of the course, participants will be able to:

• Understand SELinux core concepts and architecture.
• Assign a SELinux type to new services, files, or apps.
• Create and modify SELinux policies.
• Read and resolve AVC denials.
• Apply SELinux security best practices without introducing vulnerabilities.
• Gain insights into Qualcomm sepolicy and its structure.