Project Portfolio and Engineering Reviews

An embedded low-level development project for an IoT communication control module, focused on reusable multi-interface drivers, persistent data storage, and stable acquisition paths.

I handled multi-interface driver wrapping, FatFS storage deployment, RTC timestamp stability, and GX30H05 multi-channel acquisition debugging.

The system combined many interfaces and long data paths. Application-level communication errors could come from level mismatch, timing jitter, coupled driver calls, or blocking file writes.

I pushed board-specific capabilities into the BSP layer and kept business flow in the App layer. For suspected hardware-path issues, I compared software timing against real waveforms instead of guessing from code alone.

The project produced a reusable driver structure, raised code reuse by more than 50%, and turned interface debugging records into team documentation for later module integration.

An embedded Linux multimodal system for home interaction scenarios, focused on concurrency boundaries and graceful degradation on a resource-limited device.

I worked on Linux application task decomposition, dependency cross-compilation, Framebuffer display, audio playback integration, and network-failure fallback logic.

Blocking AI requests and local sensor sampling operate on different time scales. If they share one execution path, network fluctuation directly slows display and sensor response.

I isolated high-latency network work from local sampling, used multiple threads for AI interaction, environment reads, and display feedback, and kept local rules available when the network path failed.

The system completed multi-dependency cross-compilation and thread-level decoupling. During unstable network conditions, it still retained environment sampling, alerts, and basic interaction.

A vision and robotic-control project for Chinese chess, focused on turning algorithm output into repeatable physical movement.

I handled piece detection, coordinate mapping, error compensation, game-search integration, and robotic-arm motion control.

Image coordinates, board grids, and arm execution positions are not in the same space. Small mapping errors become visible placement offsets during the final move.

I used nine-point calibration to build the board mapping, fitted compensation curves for arm movement error, and split recognition, decision, and execution into separately verifiable loop nodes.

The system achieved +/-0.5 mm repeat positioning accuracy and controlled inference response within 300 ms. It also received national innovation-program approval and an invention patent.

A data-knowledge-insight agent demo for medical sample data, focused on turning raw data into structured knowledge, question answering, and reusable analysis outputs.

I designed the task plan, data-processing operators, knowledge graph construction, KGQA path, analysis pipeline, FastAPI interface, and DataMate/Nexent-style integration layer.

Structured CSV records, unstructured medical text, graph triples, QA queries, and statistical reports are different data forms. Without one pipeline, results are difficult to reuse or verify.

I split the system into data processing, knowledge construction, graph QA, data analysis, and platform integration modules. Rule-based planning handles common tasks, while LLM planning is used as a fallback path.

The repository provides a runnable demo that exports cleaned data, graph files, QA samples, reports, a SQLite database, charts, and FastAPI interfaces.

A desktop tool for personal and small-team reimbursement workflows, focused on invoice recognition, naming normalization, and price-review closure.

I worked on the Electron main process, React interface, OCR service, file handling, price evidence matching, LLM calls, and safe preview workflow.

Invoice formats and OCR output are unstable, and price review should not rely on model guesses. If AI directly renames files, recognition mistakes can become hard-to-reverse file operations.

I separated OCR, table editing, evidence matching, and LLM analysis. The AI panel only produces organization suggestions and risk analysis; the final batch rename requires user confirmation in the table.

The tool runs locally as an Electron desktop app and supports multi-format invoice recognition, incremental file naming, price reasonableness checks, and OpenAI-compatible model review.

A PC-side engineering tool for embedded joint debugging, focused on clearer data display and faster diagnosis under high-frequency serial traffic.

I implemented the PyQt5 interface, threaded serial receiving, protocol parsing, real-time curve rendering, and historical data export.

Serial data can arrive faster than human observation and UI refresh. If parsing and plotting run in one thread, the interface freezes and data accumulates.

I separated parsing from UI rendering. A background thread receives and parses frames, while the UI thread only consumes structured display data and keeps exportable history.

The tool reduced interface freezes and made high-frequency data easier to inspect. It has been used in several embedded project debugging workflows.