Julien Chagnon

Designed and implemented a custom 32-bit RISC processor in Verilog, deployed on an Altera DE0-CV FPGA development board. The processor features a single-bus datapath architecture with sixteen general-purpose registers, an ALU supporting arithmetic, logical, shift, and rotation operations, as well as multiplication and division with dedicated HI/LO registers.

The processor was developed incrementally, starting with the core datapath and register transfer mechanisms, then adding the memory subsystem with RAM, MAR, and MDR for load and store instructions, followed by a control unit implemented as a finite state machine to automate instruction fetch, decode, and execution cycles. The final stage deployed the complete processor onto a Cyclone V FPGA with I/O interfacing through switches, LEDs, and seven-segment displays.

The control unit FSM supports a complete instruction set including arithmetic, immediate, memory access, conditional branching, jump-and-link, and I/O operations. The processor was verified through simulation and operates at 1 MHz on the FPGA hardware.

I developed a complete human activity recognition system that processes raw smartphone accelerometer data to distinguish between walking and jumping. Following a structured workflow encompassing data collection, hierarchical HDF5 storage, signal visualization, preprocessing, feature extraction and normalization, classifier training, and GUI deployment, we leveraged Python’s scientific stack (pandas, h5py, scipy, scikit-learn) to import CSV files from an accelerometer app, clean and smooth the time series with forward-fill and moving-average filters, extract a suite of 40 statistical features per 5-second window, train a logistic regression classifier to over 95% accuracy, and finally package the process into a Tkinter desktop application.

Built on a Sunfounder PiCar-X base with a Raspberry Pi 4B, the car used its three onboard greyscale sensors to identify the road tape, intersections, stop lines, and crosswalks. A PID line-following controller (Kp=17, Kd=1) consumed the normalized greyscale error to compute steering angles, achieving a line-following success rate above 95% during competition. Tank-turn pivots using opposing rear wheel directions handled intersection turns at roughly 80% reliability.

The car traversed a finite state machine built from a yEd GraphML map of the entire course, parsed at runtime with xml.etree.ElementTree. The GraphNavigator class advanced one node each time the greyscale sensors detected an intersection, and used breadth-first search to compute the shortest path between any two nodes. Per-edge flags embedded in the graph (PIVOT_MIN_SPIN, BRANCH_OVERSHOOT_TIME, INTERSECTION_HOLD, HUG, SPEED, etc.) allowed individual intersections to be tuned without code changes, which proved essential during the late-stage on-mat tuning week.

Pickup and dropoff locations had no tape markings, so the car interfaced with the course-wide Vehicle Positioning and Fare System (VPFS) over an HTTP/SocketIO REST API to receive fare assignments and poll its overhead-tracked position. A background thread polled the /whereami endpoint at 0.1s intervals to detect proximity to fare endpoints without blocking the main 50 Hz control loop, while a fare-scoring function ranked candidate fares by payout / (turns + 1) to favour high-paying, low-turn routes.

While not used in the final competition implementation, I also trained a custom YOLOv5 vision model on six traffic-sign categories (Stop, Yield, No-Entry, Duck, Left-Oneway, Right-Oneway) using a self-collected dataset annotated in Roboflow. The model was quantized to INT8 and compiled for the Google Coral Edge TPU USB accelerator, running inference live on the Pi camera feed. It was ultimately disabled for competition because deterministic greyscale sensing proved more reliable than camera-based detection under variable lighting, a tradeoff that directly contributed to our top safety and overall scores.

As part of a semester-long Agile software development project, our team designed and implemented a dynamic time allocating calendar that intelligently adapts a student’s weekly schedule in real time. Built in C++ using the Qt framework, the application imports academic timetables directly from Queen’s University’s SOLUS system via .ics files and integrates them with user-entered events. The different time blocks consist of classes parsed from the .ics file, fixed events, and tasks which prompt the user for an estimated effort in hours and dynamically allocate study sessions around the existing schedule. Unlike static scheduling tools, this system dynamically redistributes the study sessions as new deadlines are added or priorities change, using a weighted time-allocation algorithm to balance workload.

The project followed the Agile Scrum methodology, with development structured around two-week sprints. Our programming was also managed through GitLab, with each feature tracked through milestones, issues, and merge requests across team members.

As part of a client-based design project, our team partnered with the Toronto Police Service to modernize the Perfex training device, a 911 dispatcher testing platform built around manual time checks and paper-based modules that is becoming outdated. We translated all five original test stations (short-story recall, reading aloud, copying critical information, simulated telephone dispatch, and map indexing) into a cohesive web interface seamlessly integrated with an Arduino taskbox housed in a portable briefcase with the goal of increasing test accuracy and repeatability.

Specifically, my roles included translating the physical layout of the original Perfex device into the physical Arduino taskbox, mapping push-buttons, sliders, and rotary encoders to mirror the look and feel of the legacy device's five stations. I co-developed the embedded Arduino code that generated physical stimuli tests through user prompts, timestamping every user action and allowing me to implement a real-time scoring system.

On the web side, I also aided our team to develop an HTML, CSS, and JavaScript web interface that replaced all paper testing modules with a modern interactive experience. Audio prompts are streamed using the Web Audio API, and spoken responses are recorded in-browser using MediaRecorder. For interactive modules like map indexing and transcription, the website validates answers in real time against expected inputs and calculates both accuracy and reaction times. Once all modules are complete, results are sent to a Node.js server which stores the data and generates a downloadable PDF report.

As part of a semester-long engineering design project in first year, I worked on the development of an Automated Fluid Dispenser designed for precise, autonomous mixing of pharmaceutical solutions within strict space, material, and safety constraints. The team prepared and submitted interim reports at key milestones.

My contributions to the project focused heavily on both the system design and the software development. I wrote the complete Arduino C++ codebase, which included coordinating three subsystems: a servo-powered powder dispensing mechanism, a motor rotating turntable, and a peristaltic pump liquid delivery system. The code used arrays to store and iterate over preset dosing instructions for five test tubes dispensing increments between 1 g and 2 g of powder per tube (± 0.2 g) and delivering 20 mL of liquid per tube, controlled with start and emergency stop buttons. I implemented precision timing and motion control logic to ensure accurate dosing, along with real-time interrupt checks for safety overrides.

Beyond programming, I contributed to designing a full SolidWorks sketch of the final assembly for 3D printed components, ensuring the gearbox, limit switch system, and test tube platform met both functional and dimensional requirements. As well as authored sections of our extensive design reports.