کتاب صوتی Rust for Embedded Systems: A Hands-On Guide

🎓 دوره آموزشی جامع

📚 اطلاعات دوره

عنوان دوره: دوره Rust for Embedded Systems: A Hands-On Guide

موضوع کلی: برنامه نویسی

موضوع میانی: راست (Rust)

📋 سرفصل‌های دوره

• 1. Introduction to Embedded Systems and Rust
• 2. Why Rust for Embedded? Safety, Performance, Concurrency
• 3. Setting Up Your Rust Embedded Development Environment
• 4. Basic Rust Syntax: Variables, Constants, Data Types
• 5. Functions, Control Flow, and Loops
• 6. Understanding Ownership: The Core Concept
• 7. Borrowing and References
• 8. Lifetimes: Ensuring Memory Safety
• 9. Structs: Custom Data Types
• 10. Enums: Representing States and Variations
• 11. Methods and Associated Functions
• 12. Traits: Defining Shared Behavior
• 13. Generics: Writing Reusable Code
• 14. Error Handling with `Result` and `Option`
• 15. Modules and Crates: Organizing Your Codebase
• 16. The `std` vs. `no_std` Environment
• 17. Customizing the Build Process: `Cargo.toml` for Embedded
• 18. Understanding Rust's Memory Model
• 19. Pointers and Raw Pointers in Rust
• 20. `unsafe` Rust: When and How to Use It Safely
• 21. The `embedded-hal` Crate and Its Importance
• 22. Introduction to Microcontrollers and Their Architectures (e.g., ARM Cortex-M)
• 23. Memory Organization: Flash, RAM, Registers
• 24. The Boot Process of an Embedded System
• 25. Cross-Compilation for Embedded Targets
• 26. Linker Scripts: Arranging Memory Sections
• 27. Flashing Your Rust Firmware to a Microcontroller
• 28. Debugging Embedded Rust with GDB and OpenOCD
• 29. `probe-rs`: A Unified Rust Debugging Tool
• 30. Introduction to Peripherals and Their Functions
• 31. General-Purpose Input/Output (GPIO)
• 32. Clocks and Clock Configuration
• 33. Interrupts and Exception Handling Basics
• 34. Reset and Power Management Fundamentals
• 35. The Embedded Rust Ecosystem: Crates, Tools, Communities
• 36. Getting Started with a Specific Board: STM32F4 Discovery
• 37. Peripheral Access Crates (PACs): Direct Register Access
• 38. Hardware Abstraction Layers (HALs): Ergonomic API Design
• 39. Blinking an LED with PACs
• 40. Blinking an LED with HALs
• 41. Reading Digital Inputs: Buttons and Switches
• 42. External Interrupts (EXTI): Responding to Pin Changes
• 43. Timers: Delays, Debouncing, and Periodic Events
• 44. Pulse Width Modulation (PWM): Controlling Analog-like Outputs
• 45. Universal Asynchronous Receiver-Transmitter (UART) Communication
• 46. Implementing a Simple Serial Echo with UART
• 47. Serial Peripheral Interface (SPI) Communication Fundamentals
• 48. Implementing a Basic SPI Master Device
• 49. Inter-Integrated Circuit (I2C) Communication Fundamentals
• 50. Implementing a Basic I2C Master Device
• 51. Analog-to-Digital Converters (ADC): Reading Analog Sensors
• 52. Digital-to-Analog Converters (DAC): Generating Analog Outputs
• 53. Direct Memory Access (DMA): Efficient Data Transfers
• 54. Watchdog Timers: System Reliability
• 55. Real-Time Clocks (RTC): Keeping Track of Time
• 56. Non-Volatile Memory (NVM) Interaction (e.g., internal Flash, EEPROM)
• 57. Implementing a Multi-Peripheral Driver (e.g., Sensor Array)
• 58. Introduction to Concurrency in Embedded Systems
• 59. Critical Sections: Protecting Shared Resources
• 60. Interrupt-Safe Data Structures
• 61. `cortex-m-rtic` (RTIC): A Real-Time Interrupt-driven Concurrency Framework
• 62. RTIC Application Structure and Task Prioritization
• 63. Sharing Data Between RTIC Tasks
• 64. Asynchronous Programming Paradigms in Embedded
• 65. `Future` Trait and Async/Await in `no_std`
• 66. `embassy`: An Async Framework for Embedded Rust
• 67. `embassy` Executors and Tasks
• 68. Asynchronous GPIO Operations with `embassy`
• 69. Asynchronous UART Communication with `embassy`
• 70. Asynchronous SPI/I2C with `embassy`
• 71. Integrating Asynchronous Drivers
• 72. Building a Concurrent Temperature Logger with RTIC
• 73. Understanding and Avoiding Deadlocks in Embedded
• 74. Memory Safety and Common Pitfalls in Embedded Rust
• 75. Custom Allocators for `no_std`
• 76. Using `static mut` and Safe Alternatives
• 77. Foreign Function Interface (FFI) with C Libraries
• 78. Building and Integrating C Code with Rust
• 79. Unit Testing Embedded Rust Code
• 80. Integration Testing on Hardware
• 81. Property-Based Testing for Embedded Systems
• 82. Optimizing Rust Code for Size and Speed
• 83. Power Consumption Optimization Techniques
• 84. Over-the-Air (OTA) Firmware Updates
• 85. Bootloaders and Their Role
• 86. Secure Boot and Firmware Integrity
• 87. Rust for Safety-Critical Embedded Systems
• 88. Memory Protection Units (MPU) and Rust
• 89. Building a Sensor Data Logger (e.g., temperature, humidity)
• 90. Interfacing with an LCD Display (e.g., SSD1306, ST7789)
• 91. Implementing a Simple User Interface with Buttons and Display
• 92. Control a Motor with PWM and Feedback
• 93. Basic Network Connectivity with ESP-IDF (Wi-Fi, Bluetooth)
• 94. Implementing a Basic HTTP Server on an Embedded Device
• 95. Communicating with Cloud Platforms (e.g., MQTT)
• 96. Developing a Simple Robotics Control Application
• 97. Case Study: Building a Small IoT Device with Rust
• 98. Future Trends and Advanced Embedded Rust Development
• 99. Final Project: A Smart Home Node (Example Integration)
• 100. Course Conclusion and Next Steps