Accomplishments

Detailed Accomplishments

 

Web API development –Using Visual Studio, and writing in C#, implemented RESTful APIs to enable operators to create and monitor television channels, stations, programs, and user accounts for live TV, VOD, and PPV – as well as handle the purchasing, billing and control the video rights to the TV broadcasts. Implemented external facing APIs to only expose certain data to the operators, proxied to internal servers to access the Mongo data base for the TV and account information, and to a Cassandra data base for account purchases and billing records. Includes the ability to upload images for TV shows, movies, station logos, and user profiles, store them in the cloud, and resize them for displaying on set top boxes, tablets and phones. Wrote tests to verify playback video rights on various devices such as set top boxes, Android and IOS devices based on the account information. Developed unit, component, and extensive functional tests for all the APIs.

Television Streaming – Implemented a C++ bridge between a web application for program selection and control of television streaming in a set top box. This software replaced the Micosoft Windows CE interface in the existing set top box used by AT&T’s U-Verse system with a linux based system controlled by a webpage. My software incorporated an open source implementation of WebSockets++, but also alternatevly allowed the system to be built using an in-house websockets implementation (just in case there were problems with the open source version). A demo of this system (Ericsson MediaFirst TV Platform) won the best-in-show award at the 2014 International Broadcasters Convention in Amsterdam. Incorporated the Azuki Systems multi-screen video platform into the Ericsson MediaFirst linux set top box by allowing the commands to either play in the existing Smooth Streaming Player, or be routed through the Azuki System which provides live TV and VOD programming through a HTTP Live Streaming (HLS) interface. Debugged, upgraded, and added encryption to an unfinished experimental HLS player in the linux set top box.

Solid State Device Management – Designed and implemented Qt GUI software to format, manage, manufacture, and monitor Solid State Devices. Program allows technician to monitor all solid-state NVMe compliant devices installed in a computer, create/delte/format namespaces, download firmware and EEPROM, monitor use and available space, plot read/write command density, troubleshoot problems, and monitor device health and temperature. Allows user to read and write specific registers within the device. As well as delivered with the solid state devices, this software  is currently being used at Microsoft to test their simulated Solid State Hard Drive device drivers.

Optical Data Recording and Playback – Designed and implemented Flash GUI in Flex/ActionScript to control new hardware device to record,  playback, and analyze  optical data – similar to (but more powerful than) LightRaid recorder. Also, designed and implemented a linux controller for a LightRaid recorder.

Realtime Embedded Software for Signal Routing, Grooming, Muxing/Demuxing – The embedded software was written in C++, and ran in an XPedite 5200 Processor. It communicated with it’s interfaces using Qt sockets, and with the hardware’s FPGAs using memory mapped addresses and also I2C drivers.

GUI development for Signal Routing,Grooming, Muxing/Demuxing – Developed various GUI’s to control and display telecommunication signal grooming. The GUI communicated with the embedded software over TCP sockets, and was written in C++ using Qt.

Telecommunications Metadata Correlator – Developed software to correlate telecommunication metadata.  Used Object-Oriented principals, three Design Patterns.  Program was in C++ with complete set of unit tests.  Used Qt 4.3 for a GUI, and many Qt containers and functions.  Communicated with ISR parsers and clients via Google Protocol Buffers over sockets.

Realtime Embedded Signal Router – Wrote software to manage various commands from outside interfaces over TCP sockets from multiple sources, and distribute to various realtime threads within the router.  Developed a complete set of automated unit tests. Monitored power readings, voltage and other emergency alarms.  Adapted existing device driver to route the signals through the hardware.  Helped the team integrate the entire system.  Used VX-Works.

Telemetry Analysis and Trending Program –  Took over a troubled project, and led a team that incorporated telemetry, built-in-test, and self-test to perform detailed analysis and trending on the data. The telemetry data was analyzed for configuration, health and safety of radar hardware. The GUI was in Tcl/TK, the plots generated via Matlab, and all the analysis and control was in C++. I used the STL extensively, and it was object-oriented. I designed all the interfaces, and wrote all the C++ code using test-directed development, where the test cases are written before or with the code to provide a complete suite of automatic test cases. Written on Sun Unix work-station, using adamulti compiler, linker, and symbolic debugger.

Expert Engine – Designed and developed artificial intelligence engine to analyze the results of built-in-tests, and determine the actual cause of the hardware failures. The program used a data base of knowledge, and compared the results of a suite of built-in-tests to thousands of possible scenarios for hardware failure. The results were presented in reports in various formats to be presented to analysts and customers. Written on Sun Unix work-station using makefiles, and dbx for debugging. Also wrote a complete suite of automatic unit tests.

Bit Error Rate Test – Created a reverse-engineering algorithm to uncompress pseudo-random radar data for h/w verification of the bit error rate at various frequencies and bandwidth / channel combinations of I/Q radar data. System engineers said it was impossible to re-create the original data once compressed, but I invented a way to do it, by generating expected compressed data sets, and using STL algorithms to search them. Also wrote suite of automatic unit tests.

Radar Image Instrumentation – Designed and developed software to collect instrumented radar data in real-time, convert and reformat the data and store it in Matlab formatted files for radar image processing in both real-time and batch modes. Radar control data was sent to different computer platforms using various military network protocols. Instead of  hard-coding the format for the network protocols, the s/w reads MS Word files which describe the format, then creates the network interfaces based on that format, and also creates MS Word output files showing the formatted data. Combined  C++ and Matlab. Written on SGI platform.

Radar Built-in-Test – Technical leader and key developer for built-in-tests of radar processor. Again I took over a troubled project, and developed the interfaces and key aspects of the built-in-test program. I combined C++ and Matlab in an innovative way that earned a Six-Sigma award. I created an object oriented architecture that allowed a large amount of reuse among the different built-in-tests. This program was a combination of real-time embedded processing in a radar processor using VxWorks, and post-analysis on a Sun Unix workstation. The software processes large amounts of I/Q data using FFT’s and other signal processing algorithms. Each test was designed to inject I/Q data into a specific part of the radar processor, collect the results, and determine the success and accuracy of the processing by the hardware – such as phase and gain computations and imbalances.

Radar Timeline Compressor – Developed an algorithm using C++ STL to compress and uncompress radar timelines. Instead of writing the data to a file, my program generated actual C++ code containing the timelines as data, that was then linked into the real-time embedded code along with routines to uncompress it. This allowed a larger number of timelines to be stored and to be uncompressed faster than the previous programs were able to do. The compressor was written on a Sun Unix workstation, and the C++ generated code was run in a real-time embedded radar processor using VxWorks.

Radar Timeline Generator – Developed a GUI-driven radar timeline generation tool which allows user to create radar system h/w commands.  Also prints RTF formatted contents of commands and plots the timelines in post-script. Allows users to select radar front-end antenna controls by name with computed engineering unit values using pulldown menus, rather than with hexadecimal numbers as had been done previously for years. Includes extensive error and consistency checks to protect radar h/w, and contains user-training displays. Was written in Object-Oriented C++ for Unix workstations using Motif. Gui’s were generated with a combination of BuilderXcessory GUI generator, and Motif calls directly from C++ code for certain windows and tables.  GUI’s included tables, plots, menus, etc.

Radar Data Analysis Tool – Developed data analysis tools to process instrumented data from radar antennas – to troubleshoot and evaluate the effectiveness of the radar systems. These programs simulate the radar processing, (including target Id and tracking) allowing the operator to validate algorithms and h/w performance, while providing statistical and graphic outputs for analysts or customers. Advanced the art of s/w tool development for radar data analysis at Raytheon SAS in three ways:

1. Created generic tools that perform data analysis without requiring new s/w to be written, saving the project cost, time, and schedule.
2. Created reusable object-oriented modules to allow new tools to be written quickly – in hours rather than weeks.
3. Advanced the capabilities of the data analysis itself by working closely with the analysts and collaborating on new ideas.

These programs were written in C++ (and some were combined with Matlab) in Unix on SGI platforms.

Real-time Embedded  Beam Steering Computers – Developed two different real-time embedded Beam Steering Controllers (BSC) for active array antennas.  These programs steer, control, calibrate, phase-up, monitor, and test airborne active array antennas, and include built-in tests (diagnostics). Software interfaces with antenna h/w, radar processors via 1553 bus and ASC bus, antenna scanners, receivers / transmitters, operator’s consoles, a CRT (over RS-232), and other h/w devices. Extensive use of memory mapped hardware communication. Data was sent to/from other platforms through GPIB using device drivers I wrote. This was a multi-threaded environment with various processes running at different levels of interrupts and priorities in the firmware. The earlier BSC was written in C, developed on a Unix H.P. work-station to run on firmware in an 80286 processor. It was debugged using a variety of STE’s (Special Test Equipment), a circuit emulator, and logic analyzers. I also wrote the STE software, which was written in C++ on a DOS P.C. The second BSC was written in Ada on a DOS P.C. using the Meridian compiler. The firmware was run in an Intel 486 processor using VMEBUS.

Invented previously unknown methods to provide visibility to the entire radar system during debugging, trouble-shooting, and system verification of BSC controller – all without interfering with real-time requirements.