Final Project Task - Embedded System Development

[GabrielEValenzuela]

This project will involve designing and implementing an embedded system in a collaborative GitHub environment. Each team of 4 students will follow a structured approach to plan, design, document, and implement the project. Below are the steps and expectations for each part of the project.

Task Breakdown

1. Project Plan and Milestones

• Objective: Develop a comprehensive project plan outlining all key stages, goals, and milestones.
• Deliverables:
  • A high-level project description (one paragraph).
  • Define the main objectives and success criteria for the project.
  • Create a timeline and assign tasks to each team member.
  • Include a checklist or Kanban-style board in GitHub Projects to track task progress. (Optional)

2. System Design Documentation

• Objective: Outline the design of the embedded system to ensure that all team members understand the structure and functionality.
• Deliverables:
  • Block diagrams or flowcharts representing the system architecture.
  • State diagrams or flow diagrams for critical functions or states.
  • Define the main modules, their purpose, and how they interact.
  • Describe the communication between different components, especially if peripherals like ADC, DAC, GPIO, or other sensors are used.

3. Implement Continuous Integration and Continuous Deployment (CI/CD) (if applicable)

• Objective: Set up a CI/CD pipeline to automate the build and test process.
• Deliverables:
  • Configure GitHub Actions to automatically build the code upon each pull request.
  • Integrate code quality checks using clang-format to enforce consistent coding style.
  • Configure unit tests and static analysis tools to catch potential issues early. (Optional)

4. Code Implementation and Style Guidelines

• Objective: Implement the code with a consistent and professional style, documented thoroughly.
• Deliverables:
  • Write clean, modular code that adheres to best practices and utilizes meaningful variable and function names.
  • Run clang-format on all code to ensure consistent styling across the project.
  • Make use of comments for code clarity and readability.

5. Comprehensive Documentation with Doxygen

• Objective: Ensure the code is thoroughly documented for ease of understanding and maintainability.
• Deliverables:
  • Document all functions, modules, and key variables using Doxygen-style comments.
  • Provide a README.md that explains the overall functionality of the code, lists team members, and includes any general notes about the codebase.
  • Use Doxygen to generate HTML documentation and commit it to a docs/ directory for easy access.

6. INSTALL.md - Installation and Setup Guide

• Objective: Provide a clear and detailed guide for building, flashing, and running the firmware on the target hardware.
• Deliverables:
  • Instructions on how to compile the code, including any specific tools or dependencies required.
  • Detailed steps for flashing the firmware onto the target hardware (e.g., using OpenOCD, ST-Link, or other tools).
  • Information about supported platforms, such as operating systems and specific microcontroller details.

7. Hardware Specifications and Schematics

• Objective: Provide all relevant details about the hardware configuration and connections.
• Deliverables:
  • A brief overview of the hardware used (microcontroller type, sensors, actuators, etc.).
  • Circuit schematics in image or SVG format that detail the connections of all components.
  • A hardware setup guide describing how components should be physically connected.

8. Additional Suggestions

• Use Git internal branches for each feature or module, and merge them only when reviewed and approved by at least two team member and team leader.
• Create a branch 1.0.0 considered the release branch, and merge only when reviewed and approved by professor.
• DO NOT MERGE TO MASTER OR MAKE COMMIT DIRECTLY
• Apply good practices of software engineering.
• Consider creating an Issue Tracker for each task and keep the conversation within the comments to log progress.
• Make use of GitHub's Wiki or Project Board features to organize and visualize the workflow.

Final Deliverable

The project should be fully implemented, tested, and documented. Each team will create a GitHub repository with all code, diagrams, and documentation completed and structured as per the requirements above. Ensure that the README.md provides a quick overview and instructions to navigate the repository effectively.

Good luck, and remember that collaboration and clear communication are key to a successful project! 🍀

---

[1v6n]

Project Plan and Milestones

• The project involves the design and implementation of an embedded air quality monitoring and control system, integrating two microcontrollers: the LPC1769 and STM32. The LPC1769 handles flow monitoring, PWM fan control, UART communication, and AQI calculation, while the STM32 simulates a PSM 5003 sensor, generating 32 bytes data frames in the same way the sensor does it. The system dynamically adjusts the fan speed based on the calculated AQI value and provides visual feedback through a DAC-controlled LED indicating the air filter’s condition. The project leverages FreeRTOS for task management and employs UART for communication between the two microcontrollers, with the potential for future integration with a real PSM 5003 sensor.

  Main Objectives

  1. Integration of LPC1769 and STM32: To successfully integrate the LPC1769 and STM32 microcontrollers to handle different tasks of the air quality monitoring and control system. The LPC1769 will manage tasks such as flow control, PWM fan control, and AQI calculation, while the STM32 will simulate a PSM 5003 sensor.

  2. Air Quality Control: To implement a dynamic fan speed control based on the AQI value derived from the received sensor data.

  3. Real-time Monitoring and Feedback: To continuously monitor the air filter’s flow and display a visual indication (using a DAC-controlled LED) that reflects the filter's condition, with adjustments made based on the detected airflow.

  4. Communication between Microcontrollers: To enable efficient UART communication between the LPC1769 and STM32 for data transmission (simulated 32 byte frame), ensuring data integrity and proper checksum verification.

  5. Testing and Simulation: To simulate real-world air quality conditions with the STM32 and fine-tune the system before implementing a real PSM 5003 sensor.

     Success Criteria

  6. Functional System: The system should correctly monitor airflow, adjust the fan speed based on the AQI value, and provide real-time feedback on the air filter’s condition via the LED.

  7. Correct Communication: UART communication between the LPC1769 and STM32 should work without data loss or corruption. The checksum verification should successfully ensure data integrity.

  8. Correct AQI Calculation and Fan Control: The AQI should be correctly calculated from the PM2.5 values of the 32 byte frame. The fan speed should adjust based on the AQI, using PWM.

  9. Scalability for Future Hardware: The system should be designed in a way that it can seamlessly integrate a real PSM 5003 sensor in the future, with minimal adjustments needed for hardware integration.

  10. Testing and Debugging: All features must be tested, including manual tests of the flow monitoring, fan control, and UART communication.

  11. Documentation and Code Quality: Code will be documented using Doxygen and styled consistently with clang-format. CI pipelines will automate style checks, testing, and builds. Comprehensive documentation, including a README and INSTALL guide, will ensure ease of use and maintainability.

      Tasks Assignment

      We utilized Google Docs to assign tasks to each team member. Google Docs Task Assignment

      System Design Documentation

      State Diagrams

      LPC1769

      

      STM32

      

      Main modules

1. Flow Monitoring Module (LPC1769)
   Purpose: Monitor the airflow through the filter and adjust the LED brightness to reflect the filter's condition.
   Functionality:

   • Uses the ADC to measure airflow from the fan (anemometer).
   • Adjusts the LED brightness via the DAC based on airflow status (higher obstruction = lower flow = brighter LED).

2. PWM Control Module (LPC1769)
   Purpose: Regulate fan speed based on the Air Quality Index (AQI) calculated.
   Functionality:

   • Calculates the appropriate PWM duty cycle based on the calculated AQI.
   • Dynamically adjusts fan speed to respond to changes in air quality.
   • Uses the LPC1769 timer and GPIO to generate a high-precision PWM signal.

3. UART RX Module (LPC1769)
   Purpose: Handle and manage the reception of data transmitted by the STM32. Functionality:

   • Receives 32-byte data frames sent by the STM32.
   • Verifies data integrity using a checksum calculation.
   • Stores data, using DMA, for further processing by other modules, such as the AQI calculation module.

4. AQI Calculation Module (LPC1769)
   Purpose: Compute the AQI value from the received PM2.5 concentration.
   Functionality:

   • Translates PM2.5 values into an AQI using standard classification tables from the sensor datasheet.
   • Transfers the calculated AQI to the PWM control module for fan speed adjustment.

5. PSM 5003 Sensor Simulation Module (STM32)
   Purpose: Simulate the behavior of a real PSM 5003 sensor for testing purposes.
   Functionality:

   • Implements adjustable PM2.5 values. Uses the ADC to read an input from a potentiometer, allowing dynamic adjustment of PM2.5 concentration.
   • Generates a 32-byte data frame, identical to those specified in the PSM 5003 datasheet.
   • Simulates real-time air quality conditions to test the LPC1769 modules.

6. Task Management Module with FreeRTOS (STM32)
   Purpose: Manage task scheduling and system stability using FreeRTOS.
   Functionality:

   • Manages specific tasks for sensor simulation and data transmission, each operating with a 500 ms interval.
   • Monitors stack usage with the high-water mark method to prevent stack overflows.

Components communication

ADC-UART Communication (STM32)

• ADC:
  • Reads input from a potentiometer, allowing dynamic adjustment of the simulated PM2.5 value.
• UART:
  • Transforms the scaled ADC output into a simulated PM2.5 value and constructs a 32-byte frame. This frame is transmitted to the LPC1769 for further processing.

ADC-DAC Communication (LPC1769)

• ADC:
  • Monitors the airflow and captures analog signals representing the air filter's condition.
  • Converts the analog signals into digital values for processing.
• DAC:
  • Takes the processed data from the ADC to control the brightness of an LED.
  • The LED provides a visual indication of the air filter's state:
  • Higher brightness indicates a more clogged filter.
  • Lower brightness indicates a clearer filter.

UART Communication (interaction Between LPC1769 and STM32)

• STM32:
  • Sends a 32-byte data frame containing:
  • Start characters (0x42, 0x4D).
  • Frame length.
  • Simulated sensor data.
  • Checksum for data integrity.
• LPC1769:
  • Receives and processes the frame:
  • Validates the checksum to ensure data integrity.
  • Extracts PM2.5 data if the checksum is correct.
  • Calculates the Air Quality Index (AQI) based on the extracted PM2.5 value.

UART-PWM Communication (LPC1769)

• LPC1769 dynamically calculates the PWM duty cycle based on AQI thresholds, utilizing data received via UART from the STM32.
• Generates PWM signals to regulate the fan speed.

---

Hardware Specifications and Schematics

Hardware Description

STM32 Microcontroller:

• Model: STM32
• Architecture: Cortex-M3, 32 bits.
• Key Peripherals:
  • ADC (Analog-to-Digital Converter):
  • 12 bits resolution.
  • Converts analog signals from a potentiometer into digital values, simulating a dynamic PM2.5 concentration.
  • UART (Universal Asynchronous Receiver-Transmitter):
  • Transmits a 32 byte data frame to the LPC1769.
  • Configuration: 9600 bps, 8 data bits, 1 stop bit, no parity.
  • DMA (Direct Memory Access):
  • Optimizes data transfer between the ADC and system memory, minimizing processor workload.

LPC1769 Microcontroller:

• Model: LPC1769
• Architecture: Cortex-M3, 32 bits.
• Key Peripherals:
  • UART:
  • Receives data from the STM32.
  • Verifies frames and extracts useful information.
  • PWM (Pulse Width Modulation):
  • GPIO based implementation.
  • Controls the fan speed based on the received AQI value.
  • DAC (Digital-to-Analog Converter):
  • 10 bit resolution.
  • Controls the LED brightness, indicating the filter state.
  • DMA (Direct Memory Access):
  • Efficiently handles data transfer between UART and system memory, reducing processor load.

Sensors and Actuators:

• PM2.5 Sensor (PSM5003):
  • Digital sensor simulated within the system using an STM32, generating a 32-byte UART frame.
  • Mimics particle concentration measurements in the air, providing realistic data for testing.
• Fan:
  • Controlled via a PWM signal from the LPC1769.
• Indicator LED:
  • Indicates the filter's condition by reflecting the level of clogging.

Interconnection

• UART:
  • TX (STM32) and RX (LPC1769) pins are connected for data frame transmission.
• Power Supply:
  • Both boards share a common ground (GND) to prevent signal reference issues.

Schematic Circuit

The provided schematic circuit will be used to identify the main connections.

• UART Connection: TX of STM32 to RX of LPC1769.
• Fan Connection: To the PWM output of the LPC1769.
• Power Supply: Shared power source for both boards.

Physical Configuration Guide

UART Connection:

• Connect the TX pin of the STM32 to the RX pin of the LPC1769.
• Share a common GND between both boards.

Fan:

• Connect to the P2.1 (PWM) pin of the LPC1769.
• Power the fan according to its specification (external source).

Indicator LED:

• Connect to the DAC (P0.26) output pin of the LPC1769.

Power Supply:

• Both boards should be connected to the same 3.3V or 5V power source (depending on the system’s internal regulator).