My name is Anthony Neher! I recently graduated from the University of Florida with a degree in computer engineering. All my life I have been interested in electronics and their prevalence in everyday life. Whether it be playing with legos as a kid to maintaining IT systems in high school, I have always enjoyed the process of creating things and solving problems. This ultimately led me to study computer engineering, where my passion for creating intersects with my fascination for the world of electrical devices.

I am currently working as a full-time embedded software engineer developing satellite laser communication terminals at CACI International

Anthony Neher

University of Florida '20, Computer Engineering

Github: github.com/anthonyneher | Linkedin: linkedin.com/in/anthony-neher | contact: anthony @ neherfamily.net

ABOUT

SKILLS

Hardware/Firmware

Embedded C/C++ programming
Board support package development
Device driver programming
Microcontrollers & embedded systems
RTOS and Unix/Linux OS
Bus protocols: UART, SPI, I2C, I2S
IOT protocols: 802.11 Wi-Fi, TCP, UDP
Troubleshooting tools: logic analyzer, oscilliscope, USB-JTAG debugging, GNU & JTAG debugger
MCU: Zynq-7000 SoC, ATxmega128A1U, TI C2000 DSP, TI MSP432, Atmega324P, Arduino, Raspberry Pi, CC3100
Schematic design and PCB layout
FPGA programming using VHDL
IDE: Modelsim, Vivado, Vitis

Software

Fluent: C/C++
Proficient: Python
Familiar: C#, Javascript, MATLAB, Javascript
ARM & AVR assembly programming
Web development: HTML/CSS, React, MongoDB
Version Control: git
Linux command line and file system
IDE: Atmel Studio, Code Composer Studio, Visual Studio
Computer vision using OpenCV
Machine Learning: Convolutional Neural Networks, Support Vector Machines

WORK EXPERIENCE

EXPERIENCE

Embedded Software Engineer: CACI International

April 2021 - Present

Developed multi-threaded application-level C++ code to control and interface with state machines, opto-electronic and mechanical hardware systems, and custom digital circuits implemented on a Zynq-7000 SoC running Free-RTOS
Implemented PID control algorithms for thermoelectric coolers and optical amplification systems
Created tests and system commands controlled via UART and Spacewire shell interfaces for system validation and in-flight control
Built Python tools for automating code generation of a C++ Flash database system and automating terminal testing
Designed HAL layer code to facilitate control, simulation, and testing of optical modulators, photonic amplifiers, photodetectors, lasers, and various other electronic hardware components
Worked with electrical, digital, and optical engineers to integrate software and bring-up opto-electronic hardware

Real-Time DSP Applications TA: University of Florida

Fall 2020

Conducted lab sessions and quizzes on real-time signal processing applications utilizing a C2000 DSP, AIC23 audio codec, I2C LCD screen, SPI SRAM, DMA, and Code Composer Studio
Hosted office hours assisting students write and understand embedded C and assembly level programs and prototype

Software Engineering Intern: Collins Aerospace

Summer 2020

Traffic Management Tool

Developed engineering maintenance tool using Visual Studio for XDR-5000 transponder testing and telemetry
Implemented virtual port server for simulating production hardware and testing maintenance tool efficacy
Designed periodic and aperiodic command transmission interface with fault visualization display, allowing for command library update via XML file upload
Leveraged knowledge in C# development, object-oriented design, Visual Studio, networking, UI programming

Software Engineering Intern: NASA

Summer 2019

Satellite Flight Software

Redesigned bundle storage algorithm by implementing circular buffer array decreasing storage time by 4%
Created C library that utilizes CBOR encoding to serialize network packets in accordance with disruption tolerant networking specifications
Established performance benchmarks to measure efficiency of spacecraft memory management algorithms
Implemented graphical interface to monitor real-time DTN network flow by writing python script to read data from ION network simulator
Leveraged knowledge in embedded system development, C programming on Ubuntu Linux, utilizing GNU debugger, GIT

PROJECTS

Autonomous Chess Robot

Overview:

This project was developed as a senior design project with the help of the amazingly talented David Rivera, who currently works as an embedded software engineer at Carrier.

The project utilizes computer vision algorithms running on a Raspberry Pi to detect valid moves made on the board.

These moves are then sent to a TI F2837xD microcontroller running on a custom PCB which controls the motors, servos, and electromagnets required to execute moves on the board.

Design and Manufacturing:

The mechanical design for this project was all based around the size of the board and the pieces. In order to move the arm across the board, a series of lead screws powered by stepper motors were utilized. The pieces had steel dowels placed in their tips, which allowed them to be picked up by an electromagnet attached to a linear servo.

The arm height had to be designed such that it would allow for the tallest piece on the board to move above the next highest piece on the board. In order to establish proper clearances and accelerate the design process, we utilized Computer Aided Design software. Once the design was finalized, custom lead screws and tracks were ordered and the wood components were hand cut using a jig saw.

Communication:

The Raspberry Pi communicates with the microcontroller board using SPI protocol. Serving as the master, the Pi initiates commands to the microcontroller which responds if necessary. A series of command codes were developed for all the necessary communications required to execute the game.

When a move is detected, the Pi sends a transmission with the type of pieces being moved and their corresponding coordinates. It also periodically checks for changes in the touch screen, updating the displayed board or changing the game difficulty when requested.

Computer Vision & Move Detection:

The computer vision algorithm used to detect board state first utilizes a perspective transform to convert the raw camera image to an image of just the chess board. A color transform is then issued on the board which converts the RGB color values to HSV (Hue, Saturation, and Value). Hue represents color as part of a 360 degree color wheel. Representing colors this way makes it easier to differentiate segments of the image based on color.

Once the image has been converted to HSV, the image is then broken down into its 64 individual squares. The OpenCV InRange function is then used to determine the pixels in each square that fall within a range of HSV values. This is done for both Blue and Orange values. If the number of pixels within one of the ranges passes a certain threshold, it can be assumed that a piece of that color is present.

Using this technique, a color map of the board can be established. Due to the fact that any legal move only changes one piece at a time, the type of piece that was moved can be inferred by cross referencing the color map of the board with the running game state. This is done by pushing every possible legal move onto the board and checking to see if the color map of that board state matches the current board state.

Touch Screen & Arm Control:

The robot features a touch screen controller that can be used to view the game history mid-game. This screen is controlled using an 8-bit parallel interface along with an Adafruit touch screen controller. This controller detects touches on the capacitive touch screen and executes an ADC conversion, initiating a hardware interrupt to the microcontroller which then reads the ADC value using I2C. This value can then be converted into an X-Y coordinate on the touch screen.

In addition to controlling the touch screen, the microcontroller also handles the execution of moves by determining the required number of stepper motor pulses to move the arm across the board. Once the arm is in place to pick up a given piece, PWM is used to control the servo to move the electromagnet into place. A transistor on the secondary PCB is used to control the current necessary to power the electromagnet.

Utilized: C & Python Programming, C2000 DSP, Raspberry Pi, OV5647 Camera, SPI, I2C, OpenCV, Servo, LCD screen, Stepper Motors, Code Composer Studio, Oscilloscope, Multimeter, Logic Analyzer, Circuit Design, Altium

Wireless Arcade Game

Overview:

This project is an implementation of the arcade game Bomber Man and was also developed with the help of David Rivera. The game itself runs on the real-time operating system G8RTOS, which was developed from scratch over a series of 6 labs during the course Microprocessor Applications 2 at UF. The game was designed to be run on two separate gaming boards which communicate with each other via Wi-Fi. In order to facilitate this, a Client-Host network was utilized.

Communication:

All communication between the client and host was done by sending a struct of information using the TI CC3100 Wi-Fi daughterboard. To initiate a game, the host would wait for the client to respond to it and a two-way handshake was initiated. After the boards were synchronized, a series of threads were added to periodically send and receive data for both the client and the host.

Game Control:

The game state was entirely controlled by the host. Using a thread to read joystick position and button presses, the client would update the host on its current input state. Once the host received the current input from the client, it would calculate the game logic for the next board state. This was done by combining the clients current joystick data with the hosts and checking to see if any player had died.

If no player had been within the bounds of an explosion then the next board state was send to the client. However, if either the host or client player had been within the bounds of an explosion, an end-of-game thread was launched and another hand-shake was initiated to synchronize the termination of the current game. Once the game was over the current running score was updated on both boards and the host board waited for a button press to initiate a new game.

Utilized: C Programming, Multithreaded Development, Eclipse, TI MSP432, CC3100 Wi-Fi Booster, UDP, LED Driver, ILI3925C LCD Driver, RTOS development

Spectrogram

Overview:

Developed a Spectrogram displaying real-time audible frequency magnitudes. This system utilizes an audio codec sampling at 48kHz. Each audio sample is sent to the C2000 DSP via an I2S transmission which is saved to a ping-pong buffer using a DMA engine. The use of a ping-pong buffer allows a 512-point fast Fourier transform algorithm to be run on one of the buffers while the other buffer is simultaneously being filled with audio samples. Additionally, a second DMA engine outputs the valid buffer data back out to the codec so that the samples can be fed back to an output speaker. In order to remove buffer artifacts from the DFT, a hamming window is applied to the audio buffer before it is run through the Fourier transform.

The LCD screen being used to display the spectrogram is updated using a 16-bit parallel communication bus. Even with the C2000 running at 200MHz, the entire screen cannot be updated fast enough to create a smooth display of the data. In order to work around this, I utilized the scrolling feature inherent in the ILI9486 LCD controller to shift the entire screen down one pixel each time a new FFT was calculated. This allowed me to only update the row of the LCD screen that was currently being displayed at the top while preserving the rest of the screen. This is a perfect example of the resource constrained environments that many embedded systems are forced to run in.

Utilizied: C Programming, TI C2000 DSP, AIC23 Audio Codec, SPI, I2S, LCD Screen, Logic Analyzer

Programmable Alarm Clock

Overview:

Created alarm clock using DS3231 Real Time Clock and external DAC to generate sine wave driving 8-ohm speaker. This alarm clock was based on the alarm clock I had growing up in my room as a child, which uses four buttons to set alarm time and clock time in minutes and hours. The system was prototyped on a breadboard and then a custom PCB was developed using Altium to house all the components.

Firmware:

The clock is powered using an Atmel Atmega324P microcontroller programmed via JTAG interface. The microcontroller receives time data from the real time clock via an I2C driver that monitored time data in terms of hours, minutes, seconds, days, and months.The time and date information was displayed using a 16x2 LCD display. This display was controlled using a driver that powered a 4 bit data interface.

Both the alarm and time of day could be updated by pressing and holding either switch two or three, which can be seen on the PCB on the bottom left below, and then cycling through the minute and hour time by switch one and two. When the alarm was triggered, a DAC chip was used to produce the sine wave that drove the speaker. A lookup table was used to generate the waveform that was sent via SPI to the DAC. In addition to displaying the time, the month and day of the year could be displayed and programmed by pressing both switch two and three and cycling through each in the same fashion as time update.

Circuitry:

The system is powered by 5 volt linear voltage regulator which provides even power distribution to the entire PCB. In order to make the system useful during the night, I created an ambient light sensor that dynamically dims the brightness of the LCD screen. This is done by using a photo-resistor in a voltage divider circuit to sense the ambient light in the room. The voltage value from the photo-resistor is the read by ADC from the microcontroller which uses that value to control a PWM output pin. Since the output current of the PWM pin is not enough to drive the backlight for the LCD, it instead drives the gate of a transistor that controls the power to the backlight. As the room darkens the PWM duty cycle decreases, decreasing the brightness of the screen.

The analog sine wave generate by the DAC was amplified by an LM389N operation amplifier to generate enough current to drive the 8-ohm speaker.

Circuitry: C programming, Atmega324P, DS3231 RTC, LCD Screen, Logic Analyzer, Circuit Design, Altium

Audio Equalizer & Effects Generator

Overview:

This project produces a series of audio effects running on a TI F2837xD DSP that received audio samples from an audio codec and stored them in a series of 256kB SRAMs to generate effects. By storing delayed samples in the SRAM chips, a variety of finite impulse response filtering techniques could be used to produce tremelo, phaser, wah-wah, vibrato and robotic sound effects in real time. The equalizer was created by utilizing three ADC values sampled from three separate potentiometers used to control the bass, treble and high frequency portions of the equalizer. The filters for the EQ were implemented using shelving filters for the bass and high frequencies and a peak filter for the treble.

Inside of a I2S receive interrupt, the samples were immediately stored to a circular buffer, which utilized two combined 256kB SRAMs to create 256k of 16-bit addressable data. The unsigned input address passed into the buffer was then anded with a 256k bitmask so the the address pointer could be incremented indefinitely without having to worry about overflow.

To produce FIR filters, the SRAMs were read however many samples back were required by the filter being implemented and the output of the filter was then sent back to the audio codec within the same interrupt routine. This ensured that the audio was being output in real time.

Utilized: C Programming, TI C2000 DSP, AIC23 Audio Codec, SPI SRAM, I2S, Logic Analyzer, Circuit Design

PROJECTS

INVOLVEMENT

Guardian Ad Litem Volunteer

Spring 2020 - Present

Over the past year I have had the immense privilege to serve as a Guardian Ad Litem Volunteer Child Advocate. Guardian Ad Litem is a government program in the state of Florida that deals directly with the child welfare system, and as such relies heavily on volunteers. As a Volunteer Child Advocate, I am responsible for advocating on behalf of children who have experienced abuse, abandonment, and neglect. This involves doing monthly visitations to the children involved in a case as well as writing court reports which directly impact the outcome of permanency decisions for those children.

The opportunity to make a meaningful impact on a child's life has been an extremely rewarding experience for me and I highly encourage anyone interested in the program to not hesitate to get involved. Programs such as GAL exist in all 50 states, and sometimes go by the name CASA. For more information go to guardianadlitem.org

INVOLVEMENT