Victor Tran

This tile-based, procedurally generated world is built upon the open-source PixelGameEngine by Javidx9. The bare-bones PixelGameEngine implements two main boiler-plate functions: reading keyboard inputs and rendering sprites from given png file paths. There are no "drag-and-drop" features or extensive libraries. The platformer physics, world chunk generation and saving, and lighting are self-implemented in C++. Techniques such as QuadTrees, a palette system, multithreading, and double buffering optimize and prevent bottlenecking the CPU. Overlaying multiple Perlin Noise maps that follow the Navarras Biome Graph generates a natural-looking procedurally generated world.

For the source code and articles explaining the developmental process please visit https://github.com/victorvantran/2DProcedurallyGeneratedWorld!

Project Scarecrow is an autonomous surveillance system that detects and deters vermin. This project uses the Google Coral Development Board, which includes a tensor processing unit (TPU). TPUs specialize in performing neural network calculations. When performing object detection, our scarecrow achieves inference times within tens of milliseconds—without the need of a high-end GPU or cloud computing! Consequently, our scarecrow can be deployed in remote, farming lands with no internet connection to stave off intruders.

For more information about this project, the hardware integration, the source code, and the project report, please visit https://github.com/victorvantran/ProjectScarecrow!

For my embedded systems class, I programmed an AtMega32 microcontroller to imitate the game, Bop-It! The game is played through increasingly difficult rounds. The player is given a time slot, which decrements per round, to perform a series of given tasks on various sensors. Each task is indicated to the player by visuals on an LCD screen and auditary notes from a speaker. The tasks can be pushing a button (bop it!), tilting a tilt sensor (shake it!), twisting a potentiometer (twist it!), and pulling an analog joystick (pull it!).

For the source code of the project, please visit https://github.com/victorvantran/BopIt!

This project is a 3D Game/Render engine based on an OpenGL v3.1 framework. Sofar, the engine is able load in high-quality CAD models using the ASSIMP library. Shaders are written for directional, point, and spotlights. The lighting is based on the Phong Lighting Model for ambient, diffuse, specular, and emissive light. In the future, the engine will incorporate rigid body physics and more advanced rendering techniques such as shadow, normal, and parallax mapping.

For the source code of the project, please visit https://github.com/victorvantran/GameEngine!

This project is a Violin tutor built with the STM32L476RG Nucleo board and a Soft Membrane Potentiometer (SoftPot). The user can place his or her finger on the SoftPot, which maps to notes on the A string of a full-sized violin. Additionally, the user can enter tutoring mode. In this mode, a tune is played and the user must play back in tandem the correct notes. If the note is off-key by a threshold amount of hertz, an indicator LED with glow red. If the note has proper intonation, the indicator LED will glow green. The user may also see his or her supposed note in frequency units (hertz) through the terminal. Note that the frequency is not measured by the sound and processed through a fourier transform. Rather, it is a sampled value from the ADC that measures the output signal of the SoftPot. In a future project, I will use digital signal processing to make a more robust embedded-device/instrument.

For the source code of the project, please see the project report

This is a research paper that aims to create a model that is able to forecast time-series data, using a limited amount of historical data. Traditionally, machine learning and neural network models need to be trained on vasts amount of training data that is similar to the testing data. Our model is able to generalize training data onto testing data that is not similar. To do this, our model uses the Siamese Twins Network and a pairwise-training regimine on California station 13 data. It is then able to generalize to California station 4 data. The purpose of such model is to extend its use out of vehicular traffic flow. For example, such a model can be used to predict river floods in areas where infrastucture has not been developed and there is limited amount of river data for said particular location.

For the source code of the project, please visit https://github.com/victorvantran/oneshot_forecasting_Caltrans_PeMS!

This project aims to aid people who are visually impaired in navigating indoor areas. This project trains a special neural network model, specialized for Google's TPU hardware. Leveraging this hardware allows for semantic segmentation inference times in the range of tens of milliseconds. With this, a device that can map a layout of walkable paths in real-time is possible.

For the notebooks of the project, please visit https://github.com/victorvantran/computer-vision-visual!

Titan Rover is a rover designed and built by students of California State University, Fullerton. For this year's iteration, I was tasked on reimplementing the robotic arm controls. New additions to arm is the STM32F446RE microcontroller in place of the Pyboard. More importantly than the hardware advantage, this microcontroller is programmed in C and C++ instead of a wrapper language. Though, there is a hardware abstraction layer (HAL) developed by STM to quickly and easily bring up projects. On top of the new microcontroller, we are incorporating FreeRTOS as a middleware. This makes our system multi-threaded and even-driven instead of using a simple and inefficient superloop.

Also, we are overhauling the joint system to include: 4 stepper motors, 1 linear actuator, and 1 BLDC motor. A CAN interface is used to communicate between the microcontroller and our main computer, the Jeton TX2. CAN messages are relayed from the main computer to the microcontroller through the SocketCAN library and processed using ROS's topic system. Afterwards, the microcontroller decodes these messages into actions for the each motor. Auxiliary communication protocols are used between the microcontroller and the motor drivers, namely UART and PWM. Also, attached to the stepper motors and BLDC motor are quadrature encoders to capture the position of the joint as feedback. Future development on the Robotic Arm Controls System would be to leverage this feedback for PID control and Inverse-Kinematics.

The Titan Rover repository is private. Feel free to contact my email for information about Robotic Arm Controller branch of the code.