Home

Overview

Skills

Recent Projects

Experience
At A Glance

History

Clients

Rates

Contact



Copyright © 2001-2014
Stone Hill Consulting, LLC


"Stone Hill Consulting" is
a registered service mark of
Michael K. Jones


Last updated on:

Below are some recently completed consulting projects. The list is by no means complete; please contact Stone Hill Consulting for a detailed list of clients, projects, and references.

Fix problems in existing Windows 64-bit driver for PMC I/O boards
An existing Windows kernel-mode device driver for a family of PMC I/O boards would hang on some systems during startup or shutdown. Fixed interrupt processing issues when Windows powered off the board.

Embedded Web Server for Water Analyzer/Controller
Implemented an embedded web server to configure and monitor a new water analyer and controller instrument. Ported the lwIP TCP/IP stack and GoAhead web server, and implemented web pages using HTML5, Javascript, jQuery, and JSON.

Tsi148 VME-PCI Bridge Driver
Modified existing Windows device driver to support both 32- and 64-bit Windows. Also added new support for RORA (Release On Register Access) interrupts, and the ability to cancel any pending waits for VME interrupts.

Program to control conductivity meter
Created an application to control a conductivity meter over USB. Written in C# using .NET 4 and Windows Forms, the program communicated with the meter over USB. The program collected data in real-time from the meter, displaying it on a graph and/or saving it to a CSV file.

Application-specific Browser
Created an application-specific browser using the Qt Webkit. The browser runs on an all-in-one PC running Windows Embedded Standard 7. The application is delivered from a web server, and runs in "kiosk mode" on the bedside PC, to deliver movies, TV, and patient care information to bedside.

IntervalZero RTX Driver
Ported an existing RTX driver to newer hardware and the latest version of RTX (2012). RTX provides hard real-time capabilities to Microsoft Windows. The driver provides access to the VME bridge chip for code running under RTX. There's also an interface for Windows to access the RTX driver.

Refactor C++ code and create unit tests
Helped refactor proprietary wavelet image compression software written in C++. Created various functional tests to verify output from the refactored code. Created unit tests using WinUnit. Fixed various latent bugs uncovered by both the functional and unit tests.

Troubleshoot and fix bugs in .NET custom control
Performed troubleshooting and debugging on a custom Gantt Chart control, written in C# using .NET 2.0 and Windows Forms. Investigated bug reports submitted by users, tracked down causes, and fixed bugs or added new features as required.

Program to test and certify a medical device
Designed and implemented a program to allow technicians to test and certify a medical device. Program was written in C# using .NET 4.0 and WPF. Implemented as a navigation-style application, it walked the technician through all of the steps necessary to verify proper operation of the machine. It communicated with the device via its serial monitoring port, in order to detect user interactions and read machine parameters.

Driver for new PC-based VME CPU Module
Desgined and implemented a KMDF device driver for the IDT Tsi148 PCI-VME bridge chip, to allow access to the VME bus from Windows programs running on PC-based singe-board computers modules. Driver was for a new board, and was based on the driver for the previous board. New driver supported the same API, so existing user-mode libraries, test applications, and customer code would continue to run unchanged.

Program to configure frozen drink machine
Designed and implemented a program to allow users to configure a machine for producing frozen beverages. Program was written in C# using .NET 3.5 and WPF. Also implemented simple communications protocol for communicating with the machine over a USB-CDC interface. Implemented the protocol on the MSP430 processor controlling the machine.

Driver for PC-based VME CPU Module
Desgined and implemented a KMDF device driver for the Tundra Universe II PCI-VME bridge chip, to allow access to the VME bus from Windows programs running on PC-based singe-board computers modules. Replaced an older legacy device driver written in C++ using Compuware/Numega DriverStudio. New driver supported the same API, so existing user-mode libraries, test applications, and customer code would continue to run unchanged.

Driver for PCI controller board
Designed and implemented a device driver for a new PCI controller board used in a therapeutic laser device. The software runs on XP Embedded. Also wrote several diagnostic programs to exercise and debug the hardware and software.

Embedded software for ARM7-based frequency generator
Worked as part of a team to develop software for a frequency generator. I was responsible for implementing the USB-CDC interface, a Telnet and a socket interface for Ethernet, and the GPIB interface (using the TNT4882 chip).

Wireless communications between PC and target device
Designed and implemented the 8051 firmware for a wireless USB dongle used to communicate with a target device. Created an ActiveX control layer to talk to the dongle using WinUSB.

Driver for semiconductor editing tool
Short-term project to help with an existing kernel-mode device driver. Driver was written in C using KMDF 1.5; analyzed driver structure and implementation for potential problems. Found and fixed several issues turned up be PreFAST and simulator testing. Implemented a background thread to parse image data as it came through, looking for events of interest to the application. Worked on performance measurement and improvements.

AVStream Driver for Multi-function video capture card
Designed and implemented an AVStream video capture driver for a multi-function CardBus card. Also creating the INF files to install the video capture and communication drivers using Microsoft's MF.SYS multi-function driver.

Port Driver to KMDF
Ported an existing device driver written in C and C++ from the Compuware / Numega DriverWorks framework to Microsoft's KMDF. The driver was also made to work with both 32- and 64-bit systems. Support for 64-bit systems also required changes in the application code (which was written in C and C++).

Project leader
Project lead for Chaos Game Engine development. The engine was initially development in Romania; I led a small team to extend and support the engine. Written in C++, the engine was a client/server 3D OpenGL-based MMORPG game environment. The client runs on Windows, and the server runs on Linux.

Prototype NDIS IM Driver for WM5 Platform
Debugged a prototype port of an NDIS IM driver from Windows to the Windows Mobile 5 platform. Tracked down and fixed porting issues, such as unaligned memory accesses, differences in driver architecture, and differences in NDIS between the two platforms. Work was in C and C++ using Visual Studio 2005.

Project Review
Performed a project review of the hardware and software for a new version of a video phone product.

Port driver to x64
Ported an existing 32-bit Windows NT device driver to x64 (AMD64). The driver was written in C++ and used the Compuware/Numega DriverWorks and DriverNetworks class library.

Kernel-mode export driver
Created a kernel-mode export driver (a.k.a. a kernel-mode DLL) to contain common cryptographic code used by multiple drivers (for FIPS certification).

NDIS 5.1 Miniport Driver
Designed and implemented an NDIS 5.1 Miniport driver for a dual-port gigabit Ethernet adapter. The hardware supported offloading IPSec processing and both IP and TCP checksum tasks. The driver was implemented in C++ using Compuware/Numega's DriverNetworks and DriverWorks class libraries. Some code was ported to Windows from an existing Linux device driver. The project included creation of INF files for installing the driver, and performance analysis using Intel's VTune Performance Analyzer.

PTY Research
Researched operation of PTY's on Linux, in preparation for porting a serial server product from Windows to Linux.

ODBC-based Event Logging System
Rewrote the event logging system, changing it to write events to a database instead of to a text file. The new code was written in C++ using STL and the libodbc++ library.

Configuration API
Designed and implemented a COM object which allows programmatic access to the configuration options of the product. Written in C++ using ATL and STL, the component is callable from C/C++, C#, VB/VBScript, and any other environment that supports COM objects.

Microsoft Management Console (MMC) Snapin
Designed and implemented two MMC snapins to manage existing server products. Written in C++ using ATL and MFC, both snapins support being loaded statically in a console, or as an extension of the "Services and Applications" node in the standard "Computer Management" console.

NetMeeting Pluggable Transport
Designed and implemented a pluggable transport for NetMeeting (using the IPluggableTransport interface). The transport allows access to the data streams for the Whiteboard and Application Sharing applets, e.g. to permit compression or encryption prior to transer.

UDP Client-Server Lock
Implemented a protocol over UDP to permit a client and server product to be "locked" to each other via a specific licensing key. The licensing protocol already existed as part of a Telnet option exchange; this project implemented the protocol over UDP.

Device Driver Code Review
Performed a code review and schedule analysis for an NT kernel-mode device driver project. In the course of the review, found (and fixed) several bugs.

Library Catalog System
Constructed a computer catalog system for the local library. To keep costs down, the server was built from scavenged parts. Debian GNU/Linux 3.0 (woody) was installed as the operating system, and Koha 2.0 was installed to handle the catalog. The library is performing a complete inventory of the stacks, and entering the data into the Koha system to build the online catalog. Volunteers enter books into Koha using a barcode scanner to read the ISBN number from each book. Koha then retrieves the MARC record for the book from the Library of Congress database using its Z39.50 gateway.

.NET Custom Control
Designed and implemented a custom control to access the administrative API functions of an existing database server. The control was written in C++ using Visual Studio .NET and ATL 7.0.

CCOW 1.2 Bridges
Implemented several "Bridges" which allow legacy applications to participate in the shared user and patient contexts with other CCOW-enabled applications. CCOW 1.2 is a Health Level 7 (HL7) context management standard.

TDI clients for Windows
Completed several projects which utilized Compuware/Numega's DriverNetworks class library (for Microsoft's TDI Client Interface) in kernel-mode device drivers for Windows 95/98 (VxD) and NT/2000/XP/2003.

Port OpenSSL to Windows kernel-mode
Ported the OpenSSL library to run in kernel-mode on Windows 95/98 (VxD) and Windows NT/2000/XP/2003, in conjunction with Compuware/Numega DriverNetworks based drivers.

USB Device Driver for Windows 98/2000/XP
Designed and implemented a WDM driver for a USB device which provides system monitoring and automatic restart capabilities. The product was originally produced for the Macintosh market; the company has expanded to include versions for Linux and Windows.

System Service daemons for Windows 98/2000/XP
Designed and implemented a daemon to work in conjunction with the USB driver (above) to provided system monitoring features. The daemon was written in C++ using a class library of my own design, which allows the same executable to run as a Service application on Windows NT/2000/XP, or as a regular background program on Windows 98.

Windows Control Panel Applets
Designed and implemented a Windows Control Panel Applet for the USB hardware and daemon (above). In addition to configuration and control, the applet provides real-time status information.

ActiveX Document Server
Designed and implemented an in-proc ActiveX Document Server using C++ and ATL. The server wraps an existing set of C DLL's which provide proprietary TIFF image viewing and annotation features. By creating an Active Document Server, those features are made available to standard container applications, like Internet Explorer and Microsoft Binder.

TIFF image compression, decompression, scaling, and display
Ported an existing set of 16-bit C- and Assembler-language DLL's to Win32. The DLL's provide TIFF image decompression, compression, scaling, and display features; annotation capabilities; and print services.

Internet Explorer Extensions
Designed and implemented of a set of COM objects to extend Internet Explorer, including a Browser Helper Object (BHO), an Explorer Bar (InfoBand) object, and a ToolBand.

TAPI 3.0 Service Provider
Designed a TAPI 3.0 Service Provider and Media Stream Provider (MSP) for H.323 video conferencing, based on the RadVision H.323 stack. Implemented of a set of generic C++ classes to wrap the TSPI and MSP entry points; these classes are meant to be used both for this project and for an H.320 Service Provider.

H.221 Engine
Designed and implemented a low-level engine to handle the H.221, H.242, H.230, and HDLC protocols in an H.320 video call. The code is written in portable C so it can be used both as a software engine in a Windows kernel-mode device driver, and as microcode in an embedded DSP on a CODEC card.

DirectX Kernel Mode Video Transport
Prototyped a device driver which uses the Kernel Mode Transport mechanism of Windows 98 to send decoded video data directly to a DirectDraw surface. The driver nearly tripled the speed at which video data could be displayed (on video cards whose driver supports the Kernel Mode Transport mechanism).

pSOS Flash File System
Rewrote the Flash File System for a pSOS-based embedded system. The old file system was simply a library of function calls, executed in the context of the caller's task. To prevent re-entrancy problems, the old code disabled all interrupts. The new file system is implemented as a separate pSOS task, and requests are queued and handled without having to disable interrupts.

NetMeeting
Designed and implemented a replacement UI for using NetMeeting within an H.320 video call. The replacement UI supports Chat, File Transfer, Whiteboard, and Application Sharing.

Also designed and implemented a pluggable transport to allow NetMeeting to run over the data channel in an H.320 video call.

Video Conferencing Device Driver
Designed an implemented an NT Kernel-mode device driver for a new CODEC card used for video conferencing. The driver is written in C++ using the Compuware/Numega Driver::Works class library. The card contains an ISDN interface; a DSP for audio encoding and decoding; a Lucent AVP chip for video encoding and decoding; and a video input/output section for collecting camera data and outputting decoded video. This driver was later ported to WDM so it would work on Windows 98.

Windows NT-based PBX
Designed and implemented a device driver to access the various functions of a custom PCI riser card (external status LED's, fan monitoring and control, temperature sensors, EEPROM, and a watchdog timer).

Designed and implemented an SNMP Extension Agent to allow monitoring and control of the PBX system from a central management console.

Designed and implemented an NT Service to monitor various system software components and restart them on failure, or to restart the entire system, including a tool to update various software components remotely from a central server.

System Tray Object
Designed and implemented an application which installs an icon in the System Tray. The icon is a COM server implemented as a singleton object; it is used by other COM objects to report status information to a central place. The icon reflects the current status, and could be expanded into a window to provide more detailed information. The window was non-rectangular, and hosted a Web Browser control to show the additional information.

Porting NT Kernel-mode Device Drivers to Windows 98
Ported a set of device drivers from Windows NT so they would run on Windows 98 (and also Windows 2000). One of the drivers was converted to WDM, which meant that the application could remain unchanged (it used DeviceIoControl to communicate with the driver). The other driver already had a VxD version; it was modified so that it could communicate with the WDM driver.