The course provides a comprehensive introduction to Embedded Linux development, combining foundational knowledge with hands-on practical experience. Participants will explore critical topics such as Linux system architecture, process management, threading, file I/O, and memory handling. Designed for professionals and enthusiasts alike, this syllabus guides learners from basic Linux operations to advanced system-level programming concepts.

The course includes:

• 🌐 Setting up a development environment for Embedded Linux.
• 🔧 Learning system calls, APIs, ABIs, and process interactions.
• 📂 Advanced file I/O techniques including memory-mapped and asynchronous operations.
• ⚙ Understanding threading models, synchronization, and race conditions.
• ⏳ Managing timers and real-time systems.
• 🌟 Preparing for device driver and kernel programming.

Who Should Attend? This course is ideal for software engineers, embedded engineers, system architects, and developers seeking to deepen their expertise in Embedded Linux.

Beginners with a basic understanding of programming can also benefit.

Upon completing the course, participants will have the necessary skills to:

• 🌐 Set up and configure Linux for embedded system development.
• 🔄 Implement advanced file and memory management techniques.
• ⏰ Utilize timers and real-time systems for performance-critical applications.
• ⚙ Transition into device driver and kernel-level programming.

Syllabus

Lesson 0: Teacher Introduction & Environment Setup

• 🌐 Setting up the development environment
  • setting up the course Virtual machine
  • 🌬️ Configuring Linux for embedded systems development

Lesson 1: Introduction to Linux

• 📝 System Calls
• 🎡 APIs vs. ABIs
• 📚 Files and Filesystem
• 👤 Processes
• ⚡ Signals
• 🔐 Inter-Process Communication (IPC) in a nutshell
• 🚫 Error Handling

Lesson 2: File I/O Basics

• 📝 Opening Files: open()
• 🔧 Creating Files: creat()
• 📊 Reading from Files: read()
  • Nonblocking Reads
• 📂 Writing to Files: write()
  • Append Mode
  • Nonblocking Writes
• ⚠ Handling Errors

Lesson 3: Advanced File I/O

• 🌮 Synchronized I/O
  • fsync() and fdatasync()
  • sync()
• 🔍 File Positioning
  • lseek()
  • Seeking Past the End of a File
• 🔄 Positional Reads and Writes
• 🔒 File Truncation
• ⚙ Multiplexed I/O
  • poll() vs. select()
• 🌐 Kernel Internals
  • Virtual Filesystem
  • Page Cache

Lesson 4: Buffered I/O

• 🔄 Working with Streams
  • Reading and Writing Streams
  • Seeking in Streams
  • Flushing Buffers
• 🔍 Opening Streams via File Descriptors
• 🔒 Thread Safety in I/O
  • Manual File Locking

Lesson 5: Advanced File I/O Techniques

• 🌈 Scatter-Gather I/O
• 🔄 Memory-Mapped I/O
• 🔍 Asynchronous I/O 
  • Working with epoll()
• ⚡ Event Notification: eventfd()

Lesson 6: Process Management

• 🔬 Programs, Processes, and Threads
• 👤 Processes
  • The exec Family
  • Using fork()
  • Process Termination
  • Waiting on Processes and Handling Zombies
  • Daemons

Lesson 7: Advanced Process Management

• 🔄 Process Scheduling
• 🌈 Yielding a Process
• 🎡 Processor Affinity
• ⏳ Real-Time Systems
• ⚖ Resource Management

Lesson 8: Introduction to Threading

• 📝 Binaries, Processes, and Threads
• 🔄 Multithreading
  • Costs and Alternatives
• 🎡 Threading Models
  • User-Level and Hybrid Threading
  • Coroutines and Fibers
• 🔄 Threading Patterns
  • Thread-per-Connection
  • Event-Driven Threading
• ⚠ Concurrency and Race Conditions
• ⚖ Synchronization
  • Mutexes
  • Deadlocks

Lesson 9: Advanced Threading

• 🔄 Pthreads
  • Creating Threads
  • Thread IDs
  • Termination
  • Joining and Detaching Threads
• 🌈 Pthread Mutexes
• 📝 Linux Threading Implementations
• 🔒 Daemon Threads

Lesson 10: File and Directory Management

• 📂 File Metadata
  • Ownership
  • Extended Attributes
• 🔍 Links
  • Hard and Symbolic Links
  • Unlinking
• 🔄 Copying and Moving Files
  • Device Nodes
• 🌐 Random Number Generator

Lesson 11: Memory Management

• 📝 Process Address Space
  • Pages, Paging, and Memory Regions
• 🌈 Dynamic Memory Allocation
  • Allocating and Freeing Memory
  • Alignment
• 🎡 Stack-Based Allocations
  • Variable-Length Arrays
• 🔍 Memory Locking
  • Locking Address Spaces
  • Checking Page Residency

Lesson 12: Timers and Time Management

• ⏳ Time Data Structures
  • POSIX Clocks
  • Time Precision
• 🔄 Getting and Setting Time
  • Process Time
  • Current Time
• ⏰ Sleeping and Waiting
  • Microsecond/Nanosecond Precision
  • Alternatives to Sleeping
• ⌛ Timers
  • Simple Alarms
  • Interval Timers
  • Advanced Timers

Wrapping Up

• 🌐 Introduction to Device Drivers
• ⚙ Basics of Kernel Programming

על המרצה:
אור סולימני, מהנדס Embedded Linux עם ניסיון של שנים בתפקידי פיתוח Real Time Embedded בסביבות High Preformence Multi-Proccess על לינוקס, פיתוח Firmware, ופיתוח אוטומציה על Raspberry PI.

 📅 מתחילים ב- 23.1.25  – פעם בשבוע – בימי חמישי

⏰בין 19:00 ל- 21:00

כל ההרצאות מוקלטות ותינתן גישה מלאה לנרשמים

הנרשמים יצורפו לקבוצת וואצאפ ייעודית עבור הקורס לטובת תמיכה, עזרה ושאלות

 

ניתן לשלם ב-3 תשלומים! צרו קשר בווטסאפ עכשיו – לחצו כאן

או התקשרו 0547-966920

מוזמנים לעבור יחד עם אור המרצה על הסילבוס ופרטים נוספים: