Tristan Brodeur

Tristan

Brodeur

About Experience Projects Publications Blog CV

Currently building Rekall. I build, ride, and rave. If I'm not building or raving, you'll likely catch me shredding the gnar on my mountain bike or skis.

Bio Born in the great state of Montana. Grew up in Las Vegas, Nevada. Currently reside in Washington D.C. I spent my childhood summers on my grandfather's farm in the sun-baked fields of North Dakota. Those months were more than just a break from school—they were the formative times that shaped my future. As I helped my grandfather repair massive farming machinery, I unknowingly planted the seeds of my passion for robotics. The intricate dance of gears, pistons, and circuitry fascinated me, each component working in harmony to ease the burden of manual labor. Of course, my father's relentless enthusiasm for sci-fi novels and movies might have played a role too—it's hard to say which influence was stronger. What I know for certain is that those summers instilled in me a profound appreciation for the hard work behind life's essentials. I witnessed firsthand how these machines, these early forms of automation, weren't just conveniences—they were catalysts for progress. Without them, I realized, society might well have found itself at a standstill. This realization sparked a vision that has driven me ever since: to create machines that can shoulder the burden of mundane, repetitive tasks. I dream of a world where human creativity and innovation are unleashed, freed from the shackles of tedious labor. This is why I fell in love with robotics. It's not just about building cool machines—it's about crafting a future where automation empowers humanity to reach new heights. Every robot I design, every line of code I write, is a step towards that vision—a vision born in those sweaty, greasy, wonderful summers on a North Dakota farm. Fast forward to today, and my path has taken an intriguing turn. While still in the robotics sphere, I'm now focused on developing automated camera systems for 3D video capture. It's a shift from alleviating workloads to transforming visual media, but the core principle remains: using technology to push boundaries. We're in the early stages of this exciting project, with more details to be revealed soon.

Work Experience

Idea Entity

Software Engineer

Mar 2023 - Jun 2024

Jasmine Energy

Principle Engineer & Co-Founder

Jul 2022 - Feb 2023

Transparent Sky

Machine Learning Lead / Research & Development Engineer

Aug 2020 - Jul 2022

Terbine

Front-End Web Developer

Oct 2017 - Mar 2020

Atlas Group LC

Full Stack Developer

Mar 2016 - Jul 2017

White Rabbit

Quality Assurance Engineer

Aug 2015 - Feb 2016

Research Experience

Hyman In Vivo Electrophysiology Lab

Undergraduate Researcher

Sep 2019 - Nov 2019

Collaborative Human-Robot Interaction Lab

Robotics REU Site Participant

Jun 2018 - Aug 2018

Drones & Autonomous Systems Laboratory

Undergraduate Researcher

Dec 2016 - Feb 2018

2020 - 2025

Live3D

Jasmine Energy dApp

Submarine Pool Robot (V2)

Submarine Pool Robot (V1)

2015 - 2020

Submarine Pool Robot (V0)

RSSI Based Multi-Robot Navigation

Furo Robot Directory Navigation

Refurbished Patio Chairs

NASA Return Challenge

Alexa "Stock Price" Skill

Potential Fields Navigation

Alexa "Hello World" Tutorial

Upcycled Shelf

AWS Lambda Tutorial

Upcycled Table

≤ 2015

FRC Robotics

Architecture Competition

Jasmine Energy dApp

dApp V1

dApp V2

dApp Final

Random

Project Overview

As a Co-Founder and Senior Software Engineer at Jasmine Energy, I led the development of a blockchain-based platform for trading Energy Attribute Certificates (EACs), modernizing processes in a $10B market previously reliant on manual operations.

Platform Development

I spearheaded the development of our decentralized application (dApp) on the Ethereum blockchain:

Architected and implemented the core smart contract infrastructure for tokenizing Renewable Energy Certificates (RECs).
Developed a permissionless trading system enabling instant settlement of EAC transactions, replacing weeks-long manual processes.
Created an automated regulatory compliance system that handles required filings and auditing when tokenized EACs are retired.
Implemented real-time price discovery mechanisms to enhance market transparency and efficiency.

Technical Stack

Designed and implemented a comprehensive full-stack architecture:

Frontend Development:

- Built with TypeScript and Node.js for type-safe, maintainable code
- Integrated Web3.js for blockchain interaction and smart contract integration
- Implemented comprehensive wallet support including MetaMask, Coinbase Wallet, and WalletConnect
- Developed real-time transaction monitoring and state management systems

Backend Infrastructure:

- Created Python-based worker services for automated REC registration and processing
- Developed event listeners for blockchain state changes and automated responses
- Implemented secure API endpoints for interaction with various REC registries
- Built automated systems for regulatory compliance and reporting

Blockchain Integration:

- Developed and deployed Ethereum smart contracts for EAC tokenization
- Created custom libraries for handling complex blockchain transactions
- Implemented gas optimization strategies for cost-effective contract deployment
- Built robust error handling and transaction recovery systems

Technical Achievements

Led the technical implementation of several key platform features:

Designed and implemented the blockchain bridging system for converting traditional RECs into tokenized EACs.
Developed smart contract architecture ensuring proper tracking and prevention of double-counting issues.
Implemented a comprehensive audit trail system for tracking energy consumption and certificate ownership.

Business Impact

Our approach led to measurable improvements in the EAC market:

Reduced transaction settlement time from days to seconds through blockchain implementation.
Decreased market costs by eliminating up to 30% middleman fees.
Improved market efficiency by 25% through implementation of transparent pricing mechanisms.
Reduced instances of double counting via on-chain token retirement tracking .
Secured $2.1 million in seed funding after presenting our MVP at Y Combinator demo day.

Environmental Impact

The platform contributes to climate action by:

Facilitating faster and more efficient financing of renewable energy projects through improved market liquidity.
Creating transparent price discovery mechanisms that help properly value renewable energy investments.
Enabling new DeFi instruments that incentivize additional investment in renewable energy infrastructure.
Supporting the global transition to clean energy by making EAC trading more accessible and efficient.

Cool Stuff

Look in the "Random" section of the gallery above to see Jasmine Energy in Times Square!

Live3D

Live3D / Textured Meshes

Machine Learning

3D Viewing Software

Hardware

Random

Project Overview

During my time at Transparent Sky, I worked on several projects focused on 3D data processing, machine learning, and visualization technologies.

Live3D

I led the development of our Live3D technology, which enhanced the way we process and visualize surveillance data:

Engineered 3D reconstruction algorithms capable of producing high-quality meshes of entire cities in just 3 minutes.
Created a comprehensive in-house library of algorithms for point-cloud processing, mesh processing, and 3D geometry processing tasks.
Implemented cutting-edge techniques such as 3D temporal differencing, point-cloud segmentation, Kd-tree & octree creation, level-of-detail (LOD) operations, reconstruction, texture-mapping, and ray-tracing.
Utilized and expanded upon industry-standard libraries like Point Cloud Library (PCL) and Cloud Compare Core Library (CCCoreLib) to enhance our processing capabilities.

Machine Learning

Shadow Removal/Detection

I led the research team in developing machine learning approaches for shadow removal and detection in aerial imagery:

Designed and implemented neural network architectures specifically tailored for identifying and eliminating shadows in various lighting conditions.
Developed a novel algorithm that combined spectral and spatial information to accurately differentiate between shadows and actual dark objects in the scene.
Created a large-scale dataset of aerial images with annotated shadows to train and validate our models.

Our shadow removal and detection algorithms greatly enhanced the quality and usability of aerial imagery for surveillance applications, while also improving the output quality of our meshes.

Super-Resolution

I led the development of super-resolution techniques for both single-image and multi-image scenarios:

Implemented and fine-tuned deep learning models such as SRCNN, ESRGAN, and DBPN for single-image super-resolution.
Developed a novel multi-image super-resolution approach that leveraged temporal information from video sequences to achieve unprecedented levels of detail.
Optimized our super-resolution pipeline for real-time processing, enabling on-the-fly enhancement of live video feeds.

Our super-resolution technology significantly improved the quality of low-resolution imagery, allowing for more detailed analysis and interpretation of aerial data.

3D Viewing Software

I took the lead in designing and developing a web-based UI for viewing and interacting with 3D mesh and point-cloud data:

Utilized Chromium Embedded Framework (CEF) to create a high-performance, cross-platform application that combined the power of C++ with the flexibility of JavaScript.
Implemented advanced rendering techniques to handle large-scale 3D datasets efficiently, including level-of-detail (LOD) management and out-of-core rendering.
Designed an intuitive user interface that allowed for seamless navigation, measurement, and annotation of 3D models.
Leveraged CesiumJS to incorporate accurate 3D representations of global terrain features:

- Implemented high-resolution digital elevation models (DEMs) from CesiumJS to render realistic mountains, valleys, and other topographical features.
- Utilized Cesium's globe rendering capabilities to seamlessly integrate our custom 3D models with worldwide terrain data.
- Optimized the integration of large-scale terrain data with our own 3D models to maintain high performance across various zoom levels and viewpoints.

Implemented the Live3D relighting system within the 3D viewer:

- Developed a robust integration system to import our custom 3D meshes onto the Cesium terrain at precise geographic locations.
- Created a real-time image projection pipeline that could handle multiple live feeds from planes, drones, and other aerial platforms.
- Implemented advanced GPU-based rendering techniques to ensure smooth performance even with high-resolution imagery and complex 3D models.
- Developed a user-friendly interface for controlling and adjusting the camera view, connecting to streaming sources, sending macros to aerial platforms, and viewing metadata about incoming frames, meshes, etc.

Our 3D viewing software set a new standard in the industry for interactive visualization of complex 3D datasets, greatly enhancing our clients' ability to analyze and interpret spatial data.

Submarine Pool Robot (V2)

Project Overview

I set out to design a robot capable of mapping a pool, cleaning both its surface and bottom, all while being entirely powered by solar energy. My father's previous pool robots were limited in functionality: they could either skim the surface and remove debris or navigate the bottom to clean the sides and floor. Each of these robots cost over $1,000, so I aimed to create a device that could perform both tasks for less than that amount. I began by considering how to create a robot with sufficient buoyancy to float on the surface while also having the ability to descend to the bottom without expending excessive energy. My initial concept involved using ballast tanks that would intake water for descent and expel it when the robot needed to charge via its solar panel or skim the surface.

V2: Dual-Cylinder Monopump Ballast System

To address the failures of the previous ballast design, I implemented two cylindrical ballast tanks using pipes and endcaps sourced from Home Depot. This configuration mitigated the pressure-related issues encountered with the rectangular design. The peristaltic pump was retained, with its output tube bifurcated to fill both tanks simultaneously. I then incorporated the bottom components: agitators for dislodging debris from the pool floor, treads for locomotion along the pool bottom, and a debris container. These components are visible in the first two photographs. Subsequently, I added side panels to house the ultrasonic sensors, as shown in the third photograph. The pool mapping algorithm utilizes solely ultrasonic sensors and operates as follows: The robot initiates its descent in 1-foot increments, gradually filling the ballast tanks while monitoring depth via pressure sensors. At each level, it emits ultrasonic pulses from its sensor array to collect distance data. The robot then executes a 360-degree rotation to comprehensively capture pool edge information. The software maintains a 3D grid representation of the pool, updating it with each set of sensor readings. As the robot descends and traverses horizontally, it constructs a detailed model of the pool's geometry. The mapping algorithm designates grid cells as either empty or occupied based on sensor data, employing probabilistic updates to manage noise. After surveying the entire pool volume, the collected data undergoes noise reduction and interpolation processes. Finally, a 3D surface reconstruction algorithm generates a mesh model of the pool, which can be exported in a standard 3D file format. To provide propulsion and facilitate water suction into the debris container, I designed and 3D printed a custom gear train driven by a 12V DC brushed motor. To protect this critical component from water ingress, I engineered a fluid-filled container to house the motor and gear assembly. This approach offered several significant advantages:

Waterproofing: The fluid-filled enclosure acts as an effective barrier, preventing water from infiltrating and damaging the motor's electrical components and the metal parts of the gearset.
Pressure equalization: In a submarine environment, external water pressure increases with depth. The fluid inside the container helps equalize this pressure, preventing deformation or damage to the motor housing and internal components. This ensures consistent performance across various depths.
Lubrication: The fluid serves as a constant lubricant for the gears and motor bearings, significantly reducing friction and wear. This is particularly important in a compact, sealed system where regular maintenance is challenging or impossible during operation.
Heat dissipation: Motors generate heat during operation, which can be detrimental in a sealed environment. The surrounding fluid efficiently conducts heat away from the motor and gears, distributing it more evenly and potentially transferring it to the outer casing. This casing then acts as a heat exchanger with the surrounding water, maintaining optimal operating temperatures.
Buoyancy adjustment: It can play a role in fine-tuning the buoyancy of the propulsion unit or the overall submarine. This allows for precise control over the robot's position and movement in the water.

However, this design presented several challenges:

Flow rate limitations: Peristaltic pumps typically offer lower flow rates compared to alternative pump types, potentially leading to slower ballast adjustments. This could be critical for the submarine's operational efficiency.
Pressure constraints: These pumps generally operate at lower pressures, which may prove insufficient at greater depths.
Tube degradation: The flexible tube in the pump is subject to wear over time, necessitating periodic replacement.
Power efficiency: Peristaltic pumps are not as efficient as other pump types for moving large volumes of water, impacting the robot's overall energy consumption.

Additionally, air compression in the ballast tanks during water intake was a significant issue:

As water was pumped into the ballast tanks, the air inside compressed according to Boyle's Law, creating increasing back-pressure against the incoming water.
This compression affected the system in several ways: a) The pump had to work harder to overcome the increasing resistance. b) Compressed air still provides some buoyancy, complicating the achievement of desired negative buoyancy for submersion. c) The compressed air expands or contracts with depth changes, causing unexpected buoyancy shifts. d) The increasing back-pressure stressed the pump, reducing its efficiency and lifespan.
These issues led to incomplete tank filling, unpredictable buoyancy behavior, and decreased energy inefficiency.

The limitations encountered with the peristaltic pump's flow rate and the challenges posed by compressed air in the ballast tanks led me to reconsider the design approach. These issues significantly impacted the robot's efficiency and reliability, prompting the development of a new design iteration.

Submarine Pool Robot (V1)

Project Overview

V1: Monopump Rectangular Ballast System

This new design aimed to significantly reduce the number of moving parts and associated costs compared to the previous piston ballast system. To achieve this, I constructed a rectangular tank using polycarbonate sheets from Home Depot, cut and epoxied together. I then incorporated a peristaltic pump, selected for its self-priming capability and reversible operation. Peristaltic pumps can handle air in the line without losing prime, making them ideal for intermittent water pumping applications. The pump's reversibility allows for both water intake and expulsion using a single mechanism. The system's intake was fitted with a filter on the robot's side panel, while the output tube fed directly into the rectangular ballast tank. To enable navigation and obstacle avoidance, I waterproofed ultrasonic sensors and integrated them into the robot's side panel. All electronic components were housed in a custom-built, openable waterproof container. Using data from the ultrasonic sensors, I developed an algorithm for obstacle detection and avoidance. To address the cleaning functionality, I 3D printed several timing pulleys. These pulleys were driven on each side by two 24V DC brushed motors, which in turn drove a belt connected to another timing pulley. This secondary pulley actuated brushes designed to disrupt debris at the pool bottom, allowing it to be sucked into the debris container. This mechanism ensured efficient cleaning while minimizing power consumption through the use of geared transmissions. Progressing through multiple design iterations provided valuable insights into hydrodynamics, material properties, and system integration. Key learnings included the importance of fluid dynamics in underwater robotics, the challenges of waterproofing electronic components, and the critical nature of efficient power management in solar-powered systems. One significant failure encountered was the inadequacy of the rectangular shape in handling large forces. Rectangular structures are inherently weak at managing high pressures due to stress concentration at the corners. Unlike curved surfaces that distribute force evenly, the sharp angles of a rectangle create weak points where material failure is likely to initiate. Additionally, flat surfaces tend to deflect under pressure, potentially leading to seal failures or structural deformation over time. This experience underscored the importance of considering pressure distribution and structural integrity in underwater design, pointing towards the superiority of cylindrical or spherical shapes for pressure vessels in aquatic applications, which would be used in my next version.

Submarine Pool Robot (V0)

Project Overview

V0: Piston Ballast Design

My first design for a ballast tank utilized piston ballasts. A piston ballast consists of a cylinder with a movable piston inside. As the piston moves, it either creates space for water to enter or forces water out, allowing the robot to control its buoyancy. To reduce costs, each piston ballast incorporated a timing pulley driven by a single servo motor to intake or expel water. However, these proved challenging to construct independently and often leaked water through the piston disk, causing issues with submersion and resurfacing. The video above demonstrates one of the failed tests using the piston ballast system. The piston ballast design proved to be fragile and prone to failure. Seal issues frequently arose, allowing air to enter and disrupt the suction process. Mechanical problems, such as misalignment or debris interfering with the piston's movement, were common. The system often struggled to create sufficient vacuum to draw in water effectively, especially at greater depths. Additionally, the intake ports were susceptible to blockages from pool debris, further hampering the ballast's functionality. The video above demonstrates one of the failed tests using the piston ballast system, highlighting the design's inherent vulnerabilities and the challenges faced in achieving reliable performance. To test the submarine's performance without initially worrying about sealing the electronics, I used a waterproof container to house the electronics and ran a long wire from the top to the sealed motors. This setup allowed me to focus on the core functionality while isolating sensitive components from water exposure. The last photo in the carousel above shows the waterproof container used for this purpose. I eventually moved on to a new design, as the fragility of this initial approach proved troublesome for long-term reliability—an essential factor when developing a product for consumer use.

NASA Return Challenge

Project Overview

This project implements an autonomous rover for the NASA Sample Return Challenge using Python. The rover is designed to navigate and map its environment, identify and collect rock samples, and return to its starting location.

Key Features

The rover demonstrates capabilities in autonomous navigation and mapping, allowing it to explore unknown terrains efficiently. It employs sophisticated obstacle avoidance techniques to ensure safe traversal through challenging environments. A key aspect of its mission is the ability to identify and collect rock samples, showcasing its potential for scientific exploration. The return-to-start functionality ensures that the rover can complete its mission cycle by returning collected samples to the designated starting point.

Technical Implementation

Perception

The rover's perception system utilizes a perspective transform to generate a top-down view of its surroundings, providing a clear understanding of the terrain layout. Color thresholding techniques are employed to distinguish between navigable terrain, obstacles, and potential rock samples. The system performs both rover-centric and world-centric coordinate transformations, enabling accurate localization and mapping.

Decision Making

The decision-making algorithm incorporates several features to ensure robust performance. It includes stuck detection and recovery mechanisms, allowing the rover to extricate itself from challenging situations. Circular motion detection and correction prevent the rover from getting trapped in repetitive patterns. The navigation system is goal-oriented, efficiently guiding the rover towards objectives while maintaining a comprehensive tracking system for sample collection.

Performance

The rover achieves an average mapping coverage of approximately 94% of its environment. The system maintains a fidelity of around 80%, ensuring reliable operation and accurate data collection throughout its mission.

Future Improvements

Future development efforts will focus on increasing the overall system fidelity, pushing beyond the current 80% benchmark. Implementation of map boundaries is planned to enable more efficient exploration strategies. Additionally, optimizing the time taken for exploration and sample collection will be a key area of improvement, enhancing the rover's efficiency in completing its objectives.

GitHub Repository

For more details and access to the code, visit the GitHub repository.

RSSI Based Multi-Robot Navigation

I was fortunate to be selected as a participant in a National Science Foundation Research Experiences for Undergraduates (NSF REU) program. This 3-month summer program supports active research participation by undergraduate students in areas funded by the National Science Foundation. Our host university was an active site participant for robotics, offering tracks in machine learning, networking, and human-robot interaction. Each participant was assigned to a specific track and paired with a graduate researcher and professor for daily and weekly project updates. I was placed in the networking track, tasked with working on networking for robotics applications. The program began with an introduction and specialized classes for each track. One of our first hands-on tasks involved hacking a robot to modify its actions. We then explored various networking aspects before being asked to develop project ideas within our assigned tracks. Intrigued by the potential of signal data in robot orientation, I proposed a project to orient an array of robots using network signals. After extensive research into networking protocols and textbooks, I discovered the Zigbee protocol, which was the standard for IoT devices at the time (now believed to be superseded by Z-wave). My concept involved attaching Zigbee modules to an array of Unmanned Ground Vehicles (UGVs) and Unmanned Aerial Vehicles (UAVs) to achieve a low computational cost solution for multi-robot navigation by monitoring the signal strength of each node in the mesh network. I had access to two UGVs and one UAV. I sourced Zigbee-compatible modules called X-Bee, which had a functional API and could communicate easily with Raspberry Pi's on the vehicles over I2C. I developed several key components:

A script for sending and receiving data packets between modules
Tests to check signal strength (as demonstrated in the video above)
Control loops based on the received signal strength

For a comprehensive technical report on the methodology, please refer to the published paper: Link The project code is available on GitHub: Link Beyond the technical project, the REU program was designed to enhance our skills as researchers and academics. We participated in weekly classes and reviews of our current papers, which significantly improved our research capabilities. This experience not only advanced our technical knowledge but also provided an opportunity to make lifelong friends among fellow participants.

Furo Robot Directory Navigation

The code for this project can be found here:Github Link In this project, Alex and I were tasked with developing a system enabling a robot to navigate a kitchen area and perform specific tasks. We utilized an existing differential drive robot, the Furo-S, for testing. Our approach divided the project into three primary objectives:

Area navigation
Object detection
Manipulation

Navigation Given time constraints and the static nature of the environment, we opted for an efficient solution. We created a scaled digital map of the kitchen based on precise measurements. Using OpenCV, we analyzed pixel intensity to identify obstacles, which were then incorporated into our map generation method. This process produced a configuration space for the robot, accounting for the Furo-S's wheelbase diameter by establishing boundary limits around obstacles. We implemented a modified A* algorithm, introducing a parameter p(n) to represent the number of turns in the robot's path. This adaptation optimized travel time by penalizing excessive turns while still finding an efficient route. To facilitate human interaction, we designed an intuitive user interface using the QT framework. This interface featured a grid of icons representing various kitchen locations and associated tasks. During testing, as demonstrated in the videos, users could select an icon to view the robot's planned path on the kitchen map, as determined by our modified A* algorithm. Object Detection Upon reaching its destination, the robot needed to identify objects relevant to the selected task. We leveraged the Furo-S's existing USB camera to obtain a live video feed of its surroundings. For object recognition, we implemented a straightforward QR code detection system using OpenCV. This method allowed for easy identification of objects tagged with QR codes, as shown in the last video above. Manipulation Due to the Furo-S platform's lack of end-effectors, we couldn't fully implement the manipulation functionalities required for our overarching goal. However, I gained valuable experience working on manipulation tasks using the Hubo platform, albeit within the constraints of its gantry system. Challenges We encountered several obstacles during the project. A significant issue arose when one of the wheel motor encoders malfunctioned. Despite our efforts, including using the lab's oscilloscope to analyze the encoder's output signals, we couldn't detect any signal from the encoder's wires. To address this, we integrated a COTS encoder from Adafruit, connecting it to an Arduino mounted on the Furo-S. This setup transmitted data to the Furo-S's main computer via serial communication. However, we later discovered that the encoder failure might have been symptomatic of a more serious power issue, as one of the motors unexpectedly caught fire after several days of testing.

Potential Fields Navigation with Festo's Robotino

Potential Fields is a concept that comes from the fundamentals of electricity and magnetism. A charge with high potential (positive) will repel the electric field away from it, while a charge with low potential (negative) will attract the electric field. With many of these attractive or repulsive points present in the electric field, a field of vectors is created representing all of the forces at each point in the field. This vector field can be navigated by following each vector at each present location, leading towards the point of lowest potential in the field (global minimum). This can be applied to robotics by creating a field where obstacles are repulsive points, and the target is an attractive point. The robot moves along the gradient of the combined potential field. This project implements an advanced potential fields navigation system for the Festo Robotino, a versatile omnidirectional mobile robot platform, integrated with a Hokuyo LIDAR scanner for real-time obstacle detection. The system demonstrates autonomous navigation in dynamic environments, skillfully avoiding obstacles while pursuing a predefined goal. At its core, the project combines three key components: the Festo Robotino for mobility and odometry, the Hokuyo LIDAR for environmental sensing, and a custom-implemented potential fields algorithm for intelligent path planning. The system architecture is built upon a robust integration of Robotino control interfaces, LIDAR data processing, and the navigation algorithm itself. In operation, an arbitrary point is set as the goal within the robot's coordinate system. The LIDAR continuously scans the environment at a rate of 10Hz, with each detected point treated as a potential obstacle. The navigation algorithm then calculates a potential field, balancing an attractive force towards the goal against repulsive forces from the detected obstacles. This resultant vector determines the robot's velocity and direction, enabling smooth and continuous movement. The main program loop cycles through position updates, LIDAR scans, potential field calculations, and movement commands at a consistent 10Hz until the goal is reached. This project showcases several key features, including real-time obstacle avoidance, smooth goal-oriented movement, adaptability to changing environments, and seamless integration of complex robotic systems. However, it also presented significant challenges, such as efficient processing of large volumes of LIDAR data in real-time, ensuring proper alignment between the Robotino's coordinate system and the LIDAR data, and fine-tuning the balance between attractive and repulsive forces for optimal navigation. Looking forward, there's potential for further enhancements, including the implementation of more sophisticated path planning algorithms for complex environments, integration of localization techniques like SLAM for improved positional accuracy, incorporation of additional sensors for more comprehensive environmental awareness, and development of a user-friendly interface for real-time monitoring and control. This project stands as a practical demonstration of advanced robotic navigation techniques, effectively combining hardware integration with algorithmic implementation to achieve autonomous movement in real-world scenarios. Below is the code:


#include <iostream>
#include <vector>
#include <cmath>
#include <chrono>
#include <thread>
#include <rec/robotino/api2/all.h>
#include <boost/asio.hpp>

struct Point
{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};

class HokuyoURG
{
private:
    boost::asio::io_service io;
    boost::asio::serial_port serial;
    std::vector<uint32_t> distances;

public:
    HokuyoURG(const std::string &port, unsigned int baud_rate)
        : serial(io, port)
    {
        serial.set_option(boost::asio::serial_port_base::baud_rate(baud_rate));
    }

    bool initialize()
    {
        write("SCIP2.0\n");
        std::string response = read();
        return response.find("SCIP2.0") != std::string::npos;
    }

    std::vector<Point> scan()
    {
        write("GD0000108000\n"); // Request scan from step 0 to step 1080
        std::string response = read();

        std::vector<Point> scan_points;

        // Check if the response starts with "GD"
        if (response.substr(0, 2) != "GD")
        {
            std::cerr << "Invalid response from LIDAR" << std::endl;
            return scan_points;
        }

        // Skip header (first two lines)
        size_t data_start = response.find('\n');
        data_start = response.find('\n', data_start + 1);
        data_start++; // Move past the newline

        // Parse the data
        const double STEP_ANGLE = 0.25 * M_PI / 180.0;    // 0.25 degrees in radians
        const double START_ANGLE = -135.0 * M_PI / 180.0; // -135 degrees in radians

        for (size_t i = 0; i < 1081; ++i)
        {
            if (data_start + 3 > response.length())
                break;

            // Extract 3 characters for each measurement
            std::string encoded_dist = response.substr(data_start, 3);
            data_start += 3;

            // Decode the distance
            int distance = (encoded_dist[0] - 0x30) << 12 | (encoded_dist[1] - 0x30) << 6 | (encoded_dist[2] - 0x30);

            // Skip invalid measurements
            if (distance == 0)
                continue;

            // Convert polar coordinates to Cartesian
            double angle = START_ANGLE + i * STEP_ANGLE;
            double x = distance * cos(angle) / 1000.0; // Convert to meters
            double y = distance * sin(angle) / 1000.0; // Convert to meters

            scan_points.emplace_back(x, y);
        }

        return scan_points;
    }

private:
    void write(const std::string &data)
    {
        boost::asio::write(serial, boost::asio::buffer(data));
    }

    std::string read()
    {
        char c;
        std::string result;
        while (boost::asio::read(serial, boost::asio::buffer(&c, 1)))
        {
            if (c == '\n')
                break;
            result += c;
        }
        return result;
    }
};

class RobotinoRobot : public rec::robotino::api2::Com
{
private:
    rec::robotino::api2::OmniDrive omniDrive;
    rec::robotino::api2::Odometry odometry;
    HokuyoURG *lidar;
    Point goal;
    std::vector<Point> obstacles;
    double attractiveConst = 1.0;
    double repulsiveConst = 100.0;
    double influenceRange = 0.5; // in meters
    double maxVelocity = 0.2;    // in m/s

public:
    RobotinoRobot(const std::string &hostname, Point goal, HokuyoURG *lidar)
        : goal(goal), lidar(lidar)
    {
        setAddress(hostname.c_str());
    }

    void updateLidarData()
    {
        obstacles = lidar->scan();
    }

    Point calculateAttractivePotential()
    {
        float x, y, phi;
        odometry.readings(&x, &y, &phi);
        double dx = goal.x - x;
        double dy = goal.y - y;
        double distance = std::sqrt(dx * dx + dy * dy);
        return Point(attractiveConst * dx / distance, attractiveConst * dy / distance);
    }

    Point calculateRepulsivePotential()
    {
        Point total(0, 0);
        float robot_x, robot_y, robot_phi;
        odometry.readings(&robot_x, &robot_y, &robot_phi);

        for (const auto &obstacle : obstacles)
        {
            double dx = robot_x - obstacle.x;
            double dy = robot_y - obstacle.y;
            double distance = std::sqrt(dx * dx + dy * dy);

            if (distance < influenceRange)
            {
                double magnitude = repulsiveConst * (1 / distance - 1 / influenceRange) / (distance * distance);
                total.x += magnitude * dx / distance;
                total.y += magnitude * dy / distance;
            }
        }
        return total;
    }

    void move()
    {
        updateLidarData();
        Point attractive = calculateAttractivePotential();
        Point repulsive = calculateRepulsivePotential();

        double vx = attractive.x + repulsive.x;
        double vy = attractive.y + repulsive.y;

        // Normalize and scale velocity
        double magnitude = std::sqrt(vx * vx + vy * vy);
        if (magnitude > maxVelocity)
        {
            vx = (vx / magnitude) * maxVelocity;
            vy = (vy / magnitude) * maxVelocity;
        }

        // Robotino uses a different coordinate system, so we need to adjust
        omniDrive.setVelocity(vy, -vx, 0); // x and y are swapped, and x is negated

        float x, y, phi;
        odometry.readings(&x, &y, &phi);
        std::cout << "Robot at (" << x << ", " << y << "), φ = " << phi << std::endl;
    }

    bool reachedGoal()
    {
        float x, y, phi;
        odometry.readings(&x, &y, &phi);
        double dx = goal.x - x;
        double dy = goal.y - y;
        return std::sqrt(dx * dx + dy * dy) < 0.1;
    }

    void errorEvent(const char *errorString) override
    {
        std::cerr << "Error: " << errorString << std::endl;
    }

    void connectedEvent() override
    {
        std::cout << "Connected to Robotino" << std::endl;
    }

    void connectionClosedEvent() override
    {
        std::cout << "Connection to Robotino closed" << std::endl;
    }
};

int main()
{
    HokuyoURG lidar("/dev/ttyACM0", 115200);
    if (!lidar.initialize())
    {
        std::cerr << "Failed to initialize LIDAR" << std::endl;
        return 1;
    }

    RobotinoRobot robot("172.26.1.1", Point(10, 15), &lidar); // Replace IP with your Robotino's IP

    if (!robot.connect())
    {
        std::cerr << "Failed to connect to Robotino" << std::endl;
        return 1;
    }

    while (!robot.reachedGoal())
    {
        robot.move();
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 10 Hz update rate
    }

    robot.omniDrive.setVelocity(0, 0, 0); // Stop the robot
    std::cout << "Goal reached!" << std::endl;

    robot.disconnect();
    return 0;
}

Alexa "Stock Price" Skill

For this project, I developed a custom Alexa skill that provides users with real-time stock market information. The skill enables users to query Alexa for current stock prices, as well as daily highs and lows for specific companies. To implement this functionality, I leveraged the Beautiful Soup Python package to perform web scraping on Yahoo Finance pages, extracting up-to-date stock data based on company ticker symbols. While the skill's scope was initially limited to a predefined dictionary of major tech firms and their corresponding ticker symbols, it successfully demonstrated the concept and functionality for these high-profile stocks. The project showcased my abilities in voice user interface design, API integration, web scraping techniques, and working with Amazon's Alexa Skills Kit. You can grab the code and follow along in the tutorial series here: Link

Architecture Competition

During my high school years, I attended a magnet school that offered specialized programs, and I was enrolled in the 'Engineering & Design' track. This program exposed us to a diverse range of engineering projects, including CADD, civil engineering, architecture, and digital electronics. In our senior year civil engineering class, we had the opportunity to participate in an AIA Las Vegas architecture competition. The challenge was to design a building based on specifications for what would become the 'Container Park' in downtown Las Vegas. The key requirements included:

creating an outdoor area for events, socialization, and dining
incorporating sustainable design elements
combining both retail and housing within the structure

For my submission to the architecture competition, I designed a unique complex using AutoDesk Revit. The design featured two buildings arranged in an "LV" formation, symbolizing Las Vegas. The "L" building was designated for housing, while the "V" building housed retail spaces. A distinctive feature of my design was the incorporation of two waterfalls in the outdoor area, with water cascading down glass walls beneath a glass walkway connecting the retail and housing buildings. This created a visually striking and immersive environment. The outdoor space also included dining areas on the ground floor of the "L" building, enhancing the social aspect of the complex. To address the harsh Las Vegas climate, I integrated a shaded outdoor area beneath the "V" building, providing a comfortable space for activities protected from the intense sun. This design not only met the competition's criteria but also aimed to create a functional, aesthetically pleasing, and climate-responsive urban space.

FRC Robotics

First Robotics Competition (FRC) is an international high school robotics competition. Each year, teams of high school students, coaches, and mentors work during a six-week period to build robots that weigh up to 125 pounds (57 kg) capable of competing in that year's unique game. The competition was founded in 1992 by inventor Dean Kamen and MIT professor Woodie Flowers. FRC combines the excitement of sport with the rigors of science and technology, aiming to inspire innovation and foster well-rounded life capabilities including self-confidence, communication, and leadership. I was a founding member of my high school's team 4800 Rage Against The Machines. I had always been interested in robotics, so when I learned that my school was starting a robotics club focused on designing, coding, and building robots, I jumped at the opportunity. Through this club, I found lifelong friends who all also had a passion for robotics, and learned everything from electronics to pneumatics. The experience was invaluable, providing hands-on experience with real-world engineering challenges and fostering teamwork skills that have been beneficial throughout my academic and professional career. I was the lead of the pneumatics team throughout my time with FRC Team 4800. Pneumatics plays a crucial role in many FRC robots, providing powerful and lightweight actuation for various mechanisms. As the pneumatics lead, I was responsible for designing and implementing systems that used compressed air to control robot functions. This involved working with components such as air compressors, solenoid valves, and pneumatic cylinders. The role taught me about system design, pressure regulation, and the importance of safety in working with compressed air systems. It also allowed me to collaborate closely with other sub-teams to integrate pneumatic systems seamlessly into the overall robot design.

Upcycled Shelf

For this project, I repurposed leftover plywood and 2x4's to create a leaning wall bookshelf for the robotics lab, building upon knowledge gained from a previous upcycled coffee table project. The process began with a quick sketch of the desired design, followed by cutting the 2x4's to specifications. I angled both ends of each 2x4 to ensure proper alignment with the floor and wall. Using a countersink bit, I created recesses for screw heads at each shelf position, ensuring a flush finish. Four plywood shelves were cut to the specified dimensions, then sanded and lightly stained. After the initial staining, I secured each shelf to the 2x4 frame using two screws on each side. To achieve a consistent appearance, I applied a final coat of stain to the entire assembled piece. This project effectively utilized surplus materials while incorporating improvements based on lessons learned from previous work, resulting in a functional and aesthetically pleasing bookshelf for the lab.

Upcycled Table

For this project, I took a stockpile of wood planks, 2x4's, and 4x4's that were left over from a previous project to create a coffee table for the robotics lab. This was my first time doing any sort of woodworking, so I had to learn the basics. I started off with an overall design in Solidworks, using the dimensions of the kitchen, requirements for the coffee table, and constraints as a basis. The coffee table needed to be able to hold a certain amount of kitchen equipment, with a preferred L-shape design. The constraints include the materials I was provided (leftover wood from previous projects) and the area allowance in the kitchen. After the design was set, I began individually cleaning and sanding the wood pieces in order to prepare the surface for painting/staining. After I painted/sanded the individual pieces, I assembled the individual pieces together. The table consisted of three core parts:

Tabletop
Backsplash
Legs

For the tabletop, I began by arranging wood planks on the floor to match the intended dimensions. Using a marker and ruler, I traced the L-shape design onto the arrangement. To join the planks, I secured metal plates along the top and bottom of each neighboring plank on one side. I then cut along the marked pattern with a saw to achieve the desired L-shape. After cutting, I re-stained the wood to ensure an even finish across all pieces. To create a border for the tabletop, I used 2x4s, routing a groove in the center of the 4-inch side to match the depth of the planks. These routed 2x4s were then applied to the straight edges of the tabletop, forming a polished border that frames the piece. To create the backsplash, I repurposed an old wood lattice fence, cutting it to match the length of the tabletop's longest side. For a polished look and secure fit, I fashioned a border using a 2x4, routing a groove along the center of its 4-inch face to a depth matching the lattice thickness. This routed 2x4 serves as the top border, into which the lattice panel is inserted. To ensure stability and integrate the backsplash with the tabletop, I added another 2x4, connecting it to the ends of both the backsplash and tabletop. This backsplash complements the overall design of the table while also preventing any materials from getting onto the wall it was situated on. The table legs were crafted from 4x4 lumber, cut to a length that accounted for the required table height minus the thickness of the wood planks used for the tabletop. These legs were painted black to conceal potential shoe marks and other stains, enhancing their durability and appearance. I attached the legs to the tabletop using L-brackets for secure fastening. To ensure stability on various surfaces, I fitted the bottom of each leg with adjustable rubber feet, allowing for easy leveling of the finished table.

Refurbished Patio Chairs

For this project, I undertook the task of refurbishing old patio chairs that had been deteriorated by sun exposure. These chairs feature a classic sling/sling-rail design, where the sling-rail holds the sling taut using a channel in its midsection. I began by detaching both the top and bottom slings from each rail, then removed the screws connecting the rails to the chair base. Next, I thoroughly sanded down the aluminum chair base and sling-rails to remove the existing paint and rust caused by years of weathering. After sanding, I applied a fresh coat of paint to each piece and topped it with a weather-resistant sealant to ensure long-lasting protection against the elements. To create new slings, I purchased burlap from a fabric store and cut it to the chair's specifications, allowing extra length and width for hemming and attachment. I prepared multiple layers for each sling to enhance durability. After sewing the layers together along the edges and hemming them to prevent fraying, I had four new slings ready - two for the back and two for the seat. Finally, I inserted these new slings into the refurbished sling rails and reattached the rails to the chair base using the original screws, effectively restoring the chairs to their former functionality and an improved appearance.

Analytical Image Stitching in Non-Rigid Multi-Camera WAMI

IEEE Sensors Letters

Issue 3 • March-2022

Montreal, Canada (Virtual)

H. AliAkbarpour, T. Brodeur, S. Suddarth

Additional Materials

Abstract: Combining the images of multiple airborne cameras is a common way to achieve a higher scene coverage in Wide Area Motion Imagery (WAMI). This paper proposes a novel approach, named Dynamic Homography (DH), to stitch multiple images of an airborne array of ’non-rigid’ cameras with ’narrow’ overlaps between their FOVs. It estimates the inter-views transformations using their underlying geometry namely the relative angles between their local coordinate systems in 3D. A fast and robust optimization model is used to minimize the errors between the feature correspondenceswhich takes place when a new set of images are acquired from the camera array. The minimum number of required feature correspondences between each adjacent pair of views is only two, which relaxes the need to have a large overlapin their FOVs. Our quantitative and qualitative experiments show the superiority of the proposed method compared to the traditional ones.

Point Cloud Object Segmentation Using Multi Elevation-Layer 2D Bounding-Boxes

ICCV Workshop on Analysis of Aerial Motion Imagery (WAAMI)

2021

Montreal, Canada (Virtual)

T. Brodeur, H. AliAkbarpour, S. Suddarth

Abstract: Segmentation of point clouds is a necessary pre-processing technique when object discrimination is neededfor scene understanding. In this paper, we propose a seg-mentation technique utilizing 2D bounding-box data ob-tained via the orthographic projection of 3D points onto aplane at multiple elevation layers. Connected componentsis utilized to obtain bounding-box data, and a consistencymetric between bounding-boxes at various elevation layershelps determine the classification of the bounding-box toan object of the scene. The merging of point data withineach 2D bounding-box results in an object-segmented pointcloud. Our method conducts segmentation using only thetopological information of the point data within a dataset,requiring no extra computation of normals, creation of anoctree or k-d tree, nor a dependency on RGB or intensitydata associated with a point. Initial experiments are run ona set of point cloud datasets obtained via photogrammet-ric means, as well as some open-source, LIDAR-generatedpoint clouds, showing the method to be capture agnostic.Results demonstrate the efficacy of this method in obtaininga distinct set of objects contained within a point cloud.

Search and Rescue Operations with Mesh Networked Robots

IEEE Ubiquitous Computing, Electronics and Mobile Communication Conference (UEMCON)

2018

Columbia University; New York City, NY

T. Brodeur, P. Regis, D. Feil-Seifer, S. Sengupta

Abstract: Efficient path planning and communication of multirobot systems in the case of a search and rescue operation is a critical issue facing robotics disaster relief efforts. Ensuring all the nodes of a specialized robotic search team are within range, while also covering as much area as possible to guarantee efficient response time, is the goal of this paper. We propose a specialized search-and-rescue model based on a mesh network topology of aerial and ground robots. The proposed model is based on several methods. First, each robot determines its position relative to other robots within the system, using RSSI. Packets are then communicated to other robots in the system detailing important information regarding robot system status, status of the mission, and identification number. The results demonstrate the ability to determine multi-robot navigation with RSSI, allowing low computation costs and increased search-andrescue time efficiency.

Directory Navigation with Robotic Assistance

IEEE Computing and Communication Workshop and Conference (CCWC)

2018

University of Nevada, Las Vegas; Las Vegas, NV

T. Brodeur, A. Cater, J. Chagas Vaz, P. Oh

Abstract: Malls are full of retail store and restaurant chains, allowing customers a vast array of destinations to explore. Often, these sites contain a directory of all stores located within the shopping center, allowing customers a top-down view of their current position, and their desired store location. In this paper, we present a customer centric approach to directory navigation using a service robot, where the robot is able to display the directory, and guide customers to needed destinations.