Fixed Point Library

• designed strongly typed fixed point library for use in constrained embedded environment

• uses template specialization and template meta-programming to allow intelligent conversion from dissimilar types and raw integers

CCL SDK Refactor

• organized what was previously a very ad-hoc repo with many disjoint abandoned/mutated abstractions (due to fast iteration at an early phase) into a well defined structure with clear dependency hierarchy

• designed a two-target build system (similar to CUDA) that allows for simultaneous building for our target device and host without stripping compile information from development context

• enabled IDE tool integration (using open source standards and functionality) for non-standard build setup

• Currently used tooling that interacts with internal compiler toolchain with minimal configuration: clang-format, clangd, clang-tidy

Hardware Verification

• built random instruction selector from scratch to generate complex constrained random distributions from simple queries to allow hierarchical constraint of each instruction component

• built out random test bench for major component of system

• caught crippling hardware bug in tests days before tapeout freeze, allowing RTL designers to implement a viable fix

• Designed/developed CFG based constrained instruction generator

Loader

• refactored device loader interface to provide a uniform interface across all device targets: hardware, architectural simulator, RTL/co-sim implementations, TLM wrapper

CCU ELF format

• Commonized instruction ingestion into loader by replacing text based assembly and raw binary with a more robust ELF based representation

SDK Host API

• designed robust low level C++ device access APIs to interface with loader and maintain device related context for developer use

• Added pybind11 based python interface

• Added embedded API with functional style Result Monad interface

CCL SDK V2 API

• Co-lead design effort for new SDK APIs based on lessons learned from first attempt

• Abstracted many of the hardware concepts away from user while maintaining ability to operate on data in a well informed context

• Incorporated use of functional programming style and heavy composition to separate data flow and compute logic, enabling a more building block oriented approach without excessive runtime costs

• Allowed many of the fixed flow functions from the original algorithm set to be replaced with composition based sub-tasks

Internal CCL Test Sweep Tool

• designed and implemented a code generation system that allows a developer to write multiple versions of compile-time constant code and interact with them at runtime with full context, enabling a much more expansive test structure

Architectural Simulator Maintenance and Refactor

• Implemented new V2 instruction buffer and cache

• Refactored and simplified interfaces to make component reuse easier and minimize bug propagation across modules

• Added extra profiling capabilities

• Developed aggressive unit tests for new elements added

• Created architecture for off-road autonomous system, modularizing and isolating sensor intake, sensor fusion, and path planning logic allowing concurrent development by independent teams.

• Acted as voice-of-customer for overall autonomous system, ensuring that project goals were scoped based on utility and viability of outcome within specified development period.

• Developed path planning and motion planning modules, utilizing C++ to implement efficient and safe guidance logic on Nvidia Drive PX2 hardware.

• Participated in development of UI and UX requirements for in-car tablet interfaces, ensuring that the system is accessible to general users, providing navigation utility and awareness of autonomous system status.

Halo Project (Autonomous Battery Electric Subaru Forester)

• Facilitated future development of autonomous platform through design, development, and testing of drive-by-wire system responsible for controlling steering, acceleration, and braking of vehicle.

• Established and implemented safety and redundancy requirements for drive-by-wire interfaces.

• Designed and implemented C++ embedded state machine for 32-bit ARM Cortex M3 chip for custom transmission and autonomous system control via CAN Bus communication with drive-by-wire system.

Car of the Future (Plug-In Hybrid Subaru BRZ)

• Developed and maintained electric motor logic for embedded controllers using MatLab and Simulink.

• Isolated severe lingering drivability issues to poor suspension component fitment, thereby solving a cross-team problem that had initially been attributed to the tuning of the electric motor.

• Replaced complex state machine with target speed PID, increasing drive motor control logic robustness.

Collision Avoidance Project

• Developed efficient kinematic model to predict the motion of cargo trailer chain towed by drive vehicle.

• Assisted with development, debugging, and optimization of model predictive control algorithm run in highly parallelized C++ CUDA environment.

General

• Successfully introduced development teams to Git version control.

• Introduced software testing practices for development teams resulting in increased safety, reliability, and general development performance.

• Provided engineering support to creative design team.

• Developed packaging requirements for studio surfaces.

• Verified that studio clay and CAD surfaces were criteria compliant.

• Enabled attractive studio designs by offering creative solutions to engineering conflicts.

• Released studio designs to vehicle engineering team at critical decision fixed points.