Software I have designed and implemented:
- Solid State Device Management – Qt GUI formats, manages, manufactures and monitor Solid State Hard Drives.
- Signal Grooming – Qt GUI controls and displays signal grooming, muxing, and demuxing via embedded firmware over TCP/IP sockets.
- Telecommunications Metadata Correlator – Real time correlation of telecommunications metadata via Google Protocol Buffers over TCP/IP and UDP sockets, includes Qt GUI for monitoring and control.
- Optical Data Recording and Playback – Flash GUI in Flex/ActionScript to record, playback, and analyze optical data.
- Radar Timeline Generator – Generates radar front-end control via GUI’s including tables, plots, and menu.
- Signal Grooming – Real time embedded linux C++ software performs signal muxing/demuxing and grooming of telecommunications signals. Includes automated unit test suite.
- Signal Routing – Real time VxWorks C-99 software performs signal routing and message distribution.
- Beam Steering – Embedded real time C and ada code to steer active array antennas.
- Telemetry Analysis and Trending Program – Analyzes built-in-test and self-test data of major radar system to find hardware faults and trends.
- Bit Error Rate Test –Uncompresses and verifies the bit error rate for radar data.
- Expert Engine – Analyzes the results of built-in-tests to determine the actual cause of the hardware failure
- Radar Data Analysis Tool – Multiple tools for analyzing the results of radar data collections to verify performance and locate failures.
- Instructor at Silicon Valley Code Camp on Qt Container Classes
- Six-Sigma award for taking over a troubled project as technical leader and key developer for built-in-tests. Project combined C++ and Matlab
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:
- Created generic tools that perform data analysis without requiring new s/w to be written, saving the project cost, time, and schedule.
- Created reusable object-oriented modules to allow new tools to be written quickly – in hours rather than weeks.
- 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.