Garland Consulting

Project Development Experience


Software Consultant: Fluke Electronics (September 2020 - present)

Firmware development for a Linux-based high-precision electronics calibration product. Based on the Yocto embedded Linux distribution with code written in C++ using STL. Capture of hardware-related activities from the inguard (isolated, high-accuracy) front-end and passing them across the guard crossing for analysis on the outguard side. Remote interface command support (GPIB, TELNET, serial). Enhancements to SW development infrastructure (conditional features, git, code reviews, build, exception handling/logging).

Software Consultant: T-Mobile (August - December 2023)

Assisting with embedded firmware development for the SyncUp product family.

Software Consultant: Discover Sound Technology (September - October 2020)

Firmware development for an embedded device which records/characterizes sounds of HVAC equipment to facilitate building maintenance. Based on the Nordic Semiconductor nRF52840 MCU. Analyzed use of dynamic memory and I2C communication to enhance product reliability.

Software Consultant: Discover Sound Technology (October 2019 - February 2020)

Firmware development for an embedded device which records/characterizes sounds of HVAC equipment to facilitate building maintenance. Based on the Nordic Semiconductor nRF52840 MCU. Analyzed firmware architecture in relation to use of dynamic memory and multi-priority interrupt handling. Recommended and implemented changes to enhance operation and reliability.

Software Consultant: MarqMetrix (October - November 2019)

Firmware development for an embedded device which measures chemical properties using a laser and spectral analysis. Based on the STM32F407VG MCU. Development in C++ using STM32Cube with Eclipse IDE/debugger. Reviewed high-level state machine design, set up hierarchical state machine (HSM) framework, error handling scheme, and development environment. In collaboration with Maxon Gilbert.

Software Consultant: Blue Willow Systems (April - May 2019)

Implemented non-volatile error logging and reporting mechanism for Bluetooth medical patient-monitoring device based on the Nordic Semiconductor nRF52 MCU. Investigated and corrected reliability problems involving conflicting use of FLASH by application, bootloader, and bluetooth pairing database. Developed python-based automated test using bluepy module running under Linux on Raspberry Pi. In collaboration with Maxon Gilbert.

Software Consultant: Starbucks (March 2018 - March 2019)

Firmware development for an automated beverage brewing machine under development for Starbucks. Main processor board employed an STM32F437II processor running a C++ environment based on protothreads and hierarchical state machines (HSM). Extended build system to support automated release process. Refactored aspects of the user-interface and brewing control code. Adapted LWIP TCP/IP stack to support SNTP time service client. Added support for IoT messaging over Ethernet through a Microsoft Sphere platform to the cloud. In collaboration with Maxon Gilbert.

Software Consultant: Blue Willow Systems (June - July, November - December 2018)

Reviewed architecture and implementation of Bluetooth medical patient-monitoring device based on the Nordic Semiconductor nRF52 MCU. Recommended improvements to rectify realtime performance issues. Identified problems and providing guidance for over-the-air (OTA) device firmware update (DFU). In collaboration with Maxon Gilbert.

Software Consultant: Teague (November 2017 - January 2018)

Initial configuration and bring-up of an embedded wireless concentrator with several ARM-based processors. Set up a Yocto-based development environment to generate RCW and build Linux for NXP LS1012A processor.

Software Consultant: Nytec (May 2016 - April 2017)

Bluetooth low-energy (BLE, Bluetooth Smart) firmware for the "Ocean Medallion" beaconing system developed for Carnival Cruise Lines using the Nordic Semiconductor nRF5X family MCU, SDK, and soft device (BLE stack). Implemented application-level security with public key cryptography providing authentication and confidentiality through encryption using AES-128 stream cipher, ECDH and ECDSA (micro-ecc library) without the need of bonding. During storage, device used ultra-low-power mode with activation on NFC scan and supported type-2 tag emulation.

Software Consultant: Chrono Therapeutics (April 2016)

Bluetooth low-energy (BLE, Bluetooth Smart) firmware for a medical device using the Nordic Semiconductor nRF51822 MCU, SDK, and s110 soft device (BLE stack).

Software Consultant: Chrono Therapeutics (October – December 2015)

Bluetooth low-energy (BLE, Bluetooth Smart) firmware for a medical device using the Nordic Semiconductor nRF51822 MCU, SDK, and s110 soft device (BLE stack).

Software Consultant: FiftyThree (February –  October 2015)

Developed next-generation stylus for use on tablets. Developing Bluetooth low-energy (BLE, Bluetooth Smart) firmware running on Nordic Semiconductor nRF51822 MCU, SDK, and s110 soft device (BLE stack). Development used open-source build environment (gcc/gdb within Eclipse, Segger JLINK), including support for embedded C++ under both Windows and OSX. Implemented BLE interface (7 services, 33 characteristics). Implemented over-the-air upgrade (also known as device firmware update: DFU). Designed and implemented hierarchical state machines (HSM) for managing BLE connection with application and for managing power. Implemented fail-safe persistent storage scheme combining battery-backed RAM with FLASH for retention of usage statistics and manufacturer-assigned data.

Software Consultant: Cocoanut Manor (November 2014 – January 2015)

Modified Bluetooth low-energy (BLE, Bluetooth Smart) firmware previously developed for Code Blue Consulting (below). Implemented connectable beacon (using Apple iBeacon format), including support for beaconing while connected. Optimized firmware use of peripherals to reduce power usage and increase battery life. Updated firmware to utilize s110 soft device (BLE stack) version 7.1.0. Upgraded build environment using Keil Microcontroller Development Kit (MDK) from version 4 to version 5.

Software Consultant: Code Blue Consulting (May – June 2014)

Developed firmware for a Bluetooth low-energy (BLE, Bluetooth Smart) peripheral for displaying images using an electronic ink display (low power display similar to that used in a Kindle). Ported display driver for use on a Nordic nRF51822 MCU using the S110 soft device (BLE stack) and SPI with a Pervasive Displays V230 display. Optimized image transfer speed from the iOS-based central application to the peripheral by buffering incoming write-without-response data for permanent storage in FLASH. Implemented various BLE characteristics, including the ability to read back display image and sent notification of busy status, errors, etc.

Software Consultant: FiftyThree (March – April 2014)

Contributed to various enhancements to the Bluetooth low-energy (BLE, Bluetooth Smart) “Pencil” stylus product. Modified embedded firmware to support an improved method for palm (writing) rejection. Added ability of the application on the central (running under iOS) to identify which Pencil it was recently connected with. Wrote SPI code to read accelerometer (LIS3DH) and return X-Y-Z values as a characteristic value. Investigated and recommended changes to achieve bonded pairing to allow more rapid reconnection between the peripheral and central. Also investigated and recommended an approach to allow over-the-air downloads to be interrupted and resumed.

Software Consultant: FiftyThree (October – November 2013)

Investigated and solved a communication drop-out problem occurring over Bluetooth low-energy (BLE, Bluetooth Smart) between an active stylus and an Apple iPad running iOS. Reviewed state machine design and implemented improvements resulting in an easier-to-maintain hierarchical state machine. Implemented other minor enhancements to the device implementation. Code was implemented in C using the Texas Instruments “operating system application layer” (OSAL) library running on a Texas Instruments CC2541 CPU. The stylus is now sold as the Pencil product which enhances the capabilities of FiftyThree's award-winning Paper application sold in the iTunes store.

Software Consultant: Fluke Electronics (April – July 2013)

Contributed to the specification, architecture, and design of an embedded Linux-based measurement device. Designed and specified a common fieldbus-related API by which protocol-specific bus adapters, containing device data services (DDS) for HART, Foundation Fieldbus, and PROFIBUS could be used in support of a common device object representation by the user interface. Contributed to the design of a component above the bus adapter layer which adapts the disparate bus interfaces to a common object model and interaction protocol. Work required familiarization with fieldbus device description language (DDL) as well as protocol-specific DDS components provided by various vendors. The design and API support navigation of a hierarchical data structure of device items, representing attributes of an actual device on the bus, which can be edited, queried, executed, and so on. The API included asynchronous callbacks for the bus to notify the user-interface of changes in device status, method execution, and similar asynchronous events. The API was specified using a set of C++ abstract classes (interfaces) with related documentation produced using Doxygen.

Personal Project (May 2012 – March 2013 )

On sabbatical working on a personal project.

Software Consultant: Carbon Design Group (January – April 2012)

User-interface prototype for a Linux-based medical application running on an ARM platform. User-interface was written in C++ using the Qt cross-platform application framework. High-level design partitioned into a set of cooperating active objects using hierarchical state machines (HSM). Designed, coded, and tested a generic HSM framework in C (code was shared with another developer working in C). Application, Linux, Root File System, and other packages were built using Linux Target Image Builder (LTIB).

Software Consultant: Intermec (May – December 2011)

Ported a Windows-based in-house software development logging tool from operation under Win32 to Android. Wrote Linux kernal module (LKM) to provide logging API to other kernel-mode modules and drivers running on Linux below Android. Wrote JAVA class with an interface matching android.util.Log class, but which redirected log output to the in-house logging tool so that JAVA applications could easily use the logging tool. Also wrote JNI-level shared libraries to provide C++ API for logging and to allow logging from JAVA in user-space to be seamlessly integrated with logging performed by kernel-space modules and drivers. Configured building of Android modules under Eclipse, ant, and within the overall root file system (RFS) build.

Software Consultant: Carbon Design Group (January – March 2011)

Developed embedded radio communication firmware for remote control application providing touch input to a host software application while communicating via a USB dongle attached to a PC. Remote controller and USB dongle utilized Nordic nRF24LE1/nRF24LU1 devices programmed in C using Keil development tools. Developed state machines and packet communication software utilized by remote controller and USB dongle.

Software Consultant: Fluke Electronics (September 2009 - January 2011)

Developed software for documenting process calibrator written in C++ running under embedded Linux. Responsible for design, implementation, and testing of proxy software components providing simultaneous software control of multiple analog measurement subsystems from within the digital subsystem. The implementation utilized multiple threads with resource locking to share a single I2C communication bus to control each analog subsystem. Developed and implemented an abstract interconnection model allowing arbitrary input and output “terminals” representing various software subsystems (e.g., proxies, measurement/calibration pipelines) to be dynamically interconnected as generic “connectable” components.

Software Consultant: Carbon Design Group (March 2009 - June 2009)

Developed software for the user-interface display module using within a medical device. Ported and adapted the Cairo graphics package ( to run on an embedded ARM9 (AT91SAM9261) hardware platform. Developed a graphics object scanner in python which descends a hierarchical directory structure containing graphics files and generates C++ code defining various screen layouts while packaging up the binary graphics images into an embedded file system for use by Cairo on the embedded target. Designed and implemented record logging software for storing and retrieving data on an SDCARD. Wrote software requirements specification and high-level design documents. Implemented in C++ using IAR Embedded Workbench for ARM (EWARM) and CSPY debugger.

Software Consultant: Carbon Design Group (December 2008 - July 2009)

Developed radio direction-finding software within the “Contech Pet Compass” product. Firmware written in C running on a CC2510 system-on-chip (based on an 8051 MCU and CC2500 RF transceiver). Each hand-held tracker communicates via radio to one of three beacons attached to the collar of a pet allowing the user to determine the relative direction and distance to their lost pet. Employs ultra low-power sleep mode and a beaconing cycle to maximize battery life.

Software Consultant: Philips Medical Systems (October/November 2008)

Developed new features for the bootloader within a wireless medical patient monitoring device. Responsibilities included developing the requirements followed by a staged implementation of the new features which included support for serializing and deserializing object data for non-volatile storage in serial data flash; splitting the boot process into two stages allowing the second stage to load the application into high-speed internal RAM normally occupied by the bootloader itself; and improvements to error detection and handling. Bootloader code was developed in C++ utilizing IAR Workbench/CSPY and the embOS operating system running on an ARM9 (AT91SAM9261) microcontroller.

Sr. Staff Engineer: Fluke Electronics (Nov 2004 – Feb 2008)

Technical lead of a software team of up to 15 developers implementing a next-generation high-end digital multimeter, the “Fluke 289.” Championed the specification effort using web-based documentation tools (wiki and python). Also led the high-level design (6 person-months of effort) producing UML documentation of the design for the full team. Real-time embedded code was implemented using C++ with templates in conjunction with the eCos RTOS and Portable Embedded Graphics (PEG) graphics library. Designed, implemented, and tested thread communication and control classes. Also responsible for design, implementation, and testing of interprocessor communication layer using packet protocol over SPI. Software running on both the MSP430 and ARM9 processors utilized over 100,000 LOC comprising almost 1500 classes. Upon release, the digital multimeter won the EC&M Magazine “product of the year” award.

Software Consultant: Construx Software (Sept 2004)

Retained by Construx Software Builders to perform a review of real-time embedded avionics code.

Senior Consulting Engineer: Construx Software (Oct 1999 – May 2000)

Worked as a member of a team developing an Internet-based bank forms system. The product allowed branch offices to generate custom forms tailored to the banking regulations of a given state and to fill out those forms and close customer business with minimal delay. My contribution to the project involved writing in C++ and ASP to facilitate printing of forms. I also contributed toward the definition of an internal time-tracking product. My father contracted lung cancer during this time. Upon his death in late May of 2000, I elected to take a sabbatical from technical work.

Software Consultant: IS Squared - previously Driftwood Systems (Jan 1998 – Sep 1999)

Worked as a member of a team developing a large distributed system for Sony Corporation’s FriendFactory internet service ( FriendFactory comprises numerous Java-based servers running back-end databases, internet services such as chat, nntp, email, http, and a Java-based PC client allowing members to interact with the service. Each of the components is designed in a location-independent manner to be runable on a machine located anywhere in the world and communicates with the other components using Java’s RMI (remote method invocation). The service makes extensive use of instant messaging carrying electronic notes (eNotes). My initial task included designing and implementing a common set of base classes used by each of the back-end Java servers. These base server classes provide service registration, properties file configuration, a prioritized thread pool for scheduling jobs, and the ability to remotely query and set the operational state of any server. Thereafter, I worked on a small team of 2-3 developers tasked with developing a prototype of an interactive Television system. A prototype was successfully delivered and demonstrated at an internal technical fair. A subsequent prototype included demonstration of delivery of targetted information based on demographics and user-defined preferences over a non-addressable one-way transport. Experience included design, implementation, and debugging of Java components and system administration and debugging across a diverse range of platforms (Windows NT, Solaris, Linux).

Software Consultant: - previously Traveling Software (Apr 1995 – Dec 1997)

Member of a team of 4 developers responsible for implementing the remote control component of Laplink for Windows 95 and Laplink for Windows NT. This component transfers the video, keyboard, and mouse actions of a computer across a remote link (modem, cable, or network) allowing a server computer to be controlled by a client computer at a remote site. The server’s display appears within a window on the client and the client’s mouse and keyboard actions control the server. I was initially responsible for the design and implementation of the client-side remote control component. The design involved serialization of objects over various communication links and interpretation of incoming objects representing remote drawing actions on the server which are replayed on the local client. MFC classes were used wherever possible and the code was 32-bit throughout (with the exception of a small amount of thunking to a 16-bit keyboard filtering component). The implementation required extensive use of Win32 GDI (usually via MFC GDI-related classes) and utilized a jointly developed code base shared with the server-side. A main goal of the development was to achieve a high amount of re-use between the server and client sides of the implementation. This was achieved with approximately 40% of the code base being shared by both sides of the communication link. On the Windows-NT server side of the product, I implemented a strategy using shared memory and synchronization by which display driver operations captured within kernel-mode were passed to user-mode for processing. This work involved joint development of a Windows-NT kernel-mode display driver component. The full code-base used to generate both the Windows 95 and Windows NT components (both server and client) comprised approximately 50,000 lines of C++ in over 600 source files defining approximately 650 classes.

Software Consultant: Construx Software (November, 1997)

Retained by Construx Software Builders to perform a software project assessment at Starwave Corporation. Reviewed project materials, participated in on-site interview process, and submitted recommendations to address project concerns and risks.

Software Consultant: Construx Software (November, 1996)

Retained by Construx Software Builders to perform a software project assessment at ScenicSoft Corporation. Reviewed project materials, participated in on-site interview process, and submitted recommendations to address project concerns and risks.

Software Consultant: Construx Software (August, 1996)

Retained by Construx Software Builders to perform a software project assessment at Vertigo Corporation. Reviewed project materials, participated in on-site interview process, and submitted recommendations to address project concerns and risks.

Software Consultant: Stratos Product Development Group (August 1994 - March 1995)

Member of a team of 4 developing software for an industrial rug manufacturing machine. Software system employed two PC-based platforms and a host of associated microcontrollers to control 176 needles to “tuft” yarn into backing material at up to 1,000 RPM producing carpets up to 3 meters in width and of unspecified length. Carpet pattern was derived from a bitmap file generated by a separate application. I was responsible for the entire user interface which employed an industrial touch-input screen. The user interface comprised approximately 7,000 lines of C++ residing in two class libraries. One class library provided a reusable set of UI controls (list boxes, radio buttons, text elements, windows, and the like) all specialized for touch-interaction (in lieu of a mouse or other pointing device). The other class library contained a class for each application-specific screen built upon the components of the first class library. Both class libraries made extensive use of inheritance (both single and multiple), and virtual functions resulting in a class hierarchy with an inheritance ancestry of 12 levels spanning approximately 100 classes.

Software Consultant: Frank Russell Company (March 1994 - July 1994)

Member of a team of 3 developing a Windows-based financial modeling product. The product used the client’s financial expertise and data base to optimally distribute an investor’s funds among various investment vehicles to generate a maximum return at a specified risk. The team completed investigation, specification, and estimation work to support a final build-or-buy decision by the client. The client decided to purchase a competitor’s product rather than develop the product in-house. Although the up-front analysis of the effort required to build the product led to the team’s demise, it was the preferred result over embarking on a project whose cost and schedule would have significantly exceeded the client’s expectations.

Software Consultant: Fourgen Software (December 1993 - February 1994)

Member of a team designing a financial accounting and inventory product. The product employed a CORBA-like distributed object scheme allowing different objects to span multiple computers across a network. Responsible for development of a Program Manager demo which allowed the launching of networked applications on remote UNIX machines by manipulation of icons and bitmaps on the local Windows PC. Tasks included designing a class library to support construction of a visual server (much like XWindows) which provided the font-end to the overall product. The visual server ran under Microsoft Windows (or NT) while the data base query engine and other components were hosted on a UNIX network. The client postponed full development of the distributed object framework prior to completion of the visual server library. The Program Manager demo was completed on schedule and successfully delivered.

Software Consultant: - previously Traveling Software (September 1993 - November 1993)

Member of a team developing a linking product between Microsoft Windows and a proprietary product under development by General Magic. Tasks included developing a serialization and instanciation technique for transferring objects between the General Magic product and Windows. Developed and specified an object-based information interchange format (a grammar containing 'meta data' by which serialized objects could be represented and manipulated under Windows for later restoration to the General Magic product). Gained familiarity with the OO-based MagicCap operating system and its class hierarchy.

Software Consultant: - previously Traveling Software (February 1993 - May 1993)

Designed and coded Disk Management services for LapLink for Windows product. The disk manager handled all file system-related operations and included implementation of both client and server sides of high-speed connections supporting multiple virtual communication channels. Development was implemented in C++ using DLLs, Borland tools, and OWL.

Software Consultant: - previously Traveling Software (June 1992 - January 1993)

Technical lead of a group of 6 developers producing Laplink V--a communication and file manager product. Responsibilities included specification, design, coding, testing, and product documentation as well as assisting other less-experienced technical developers. Specified, designed, and implemented automated batch-file scheduling and playback, including window-based UI supporting calendar manipulations and selection of repeating appointments. Specified, designed, and implemented drive and directory security for remote connections including passwords, file system navigation and encryption. Implemented window-based UI supporting filesystem navigation and assignment of user-specific security permissions to drives and directories.

Software Consultant: Dynapro Systems (July 1992)

Ported source code for a family of Touch Control Screens, makefiles, compiler, assembler, and linker of the AT&T Software Generation System (SGS) from running under SunOS to running under HPUX on an HP-9000 series computer. Verified port by obtaining exact byte-for-byte match in object files produced under HPUX with those previously produced un SunOS.

Software Consultant: - previously Traveling Software (March 1992 - June 1992)

Wrote test application to stress communications for testing full-duplex communications over a low-cost RF modem. The modem is now being offered as a component by National Semiconductor. (See hardware experience for related hardware work.)

Chief Software Engineer: John Fluke Mfg. Co. (June 1991 - February 1992)

Led one-half of the software portion of a large project to develop a next-generation electronic circuit board tester including multiple VXI-based instruments controlled via a MXI-bus connection from a Microsoft Windows application running on a PC. Leading a team of 5 developing the embedded real-time software shared by the VXI instruments (represented as virtual front panels under Microsoft Windows). Project responsibilities include planning and executing the software development process, scheduling, technical work, managing a budget, and performance appraisals of personnel.

Software Consultant: - previously Traveling Software (October 1990 - May 1991)

Member of development team developing a PC-based product supporting data configuration and transfer with electronic daytimers (personal information managers). Performed independent technical review of an in-house character-based windowing package modelled after Presentation Manager under OS/2. Participant in a task force to improve in-house software development techniques. Analyzed execution efficiency of a product under development to guide optimization efforts. Designed and implemented an automated regression test suite for a high-performance PC communication "engine". Wrote a technical manual describing the API for the communication engine.

Staff Software Engineer: John Fluke Mfg. Co., Inc. (1986 - Feb 1992)

Responsibilities included investigating, recommending, and implementing modern software development methodologies such as structured and object-oriented analysis and design, CASE, the use of metrics, and automated testing techniques. Mentor for less senior engineers regarding technical development techniques and software project management. The above responsibilities were performed on an ongoing basis in conjunction with software project leadership tasks described below.

Staff Software Engineer: Fluke New Data Acquisition Architecture (1990 - 1991)

One of two system architects tasked with developing the architecture of a new data acquisition product line for Fluke. This product line was based upon a 68030 slot-0 controller in a VXI chassis running the VxWorks real-time operating system. The system was to support analog measurements at rates of up to 100,000 readings per second. Voluntarily left Fluke during prototype phase to pursue opportunities as an independent consultant.

Staff Software Engineer: Fluke Helios Data Acquisition System (1989 - 1990)

Leader of software development team which took over modification of the Fluke 2287A real-time multi-channel data acquisition system to boost system throughput from 50 to 1,000 measurements per second. The development team comprised 3 software engineers, required 33 man-months, and involved approximately 13,000 lines of embedded C code.

Staff Software Engineer: Fluke Programmable Touch Screens (1988 - 1989)

Leader of software team of 3 engineers which modified the architecture of the Fluke 1030 and 1050 Touch Control Screens (see below) to host downloaded application programs.

Staff Software Engineer: Fluke ScreenBuilder project (1987 - 1988)

ScreenBuilder was designed to run under Microsoft Windows on an IBM-PC/AT and provide graphics-based editing of display screens on a Fluke Touch Control Screen (see below). This software package allowed customers to easily create display screens which implement a touch-screen based user-interface. I joined the project near the end of definition phase, and performed system-level and lower-level software design. The entire design was completed and underwent design review before the project was canceled due to adverse business conditions.

Senior Software Engineer, Staff Software Engineer: Fluke 1020, 1030, & 1050 Touch Control Screens (1984 - 1987)

Software Project Manager and technical team leader during development of the entire line of Fluke Touch Control Screens. I led all software-related work including product definition, software requirements generation, scheduling of software, technical software design, planning and implementation of software testing, and editing the programmer's manual. My technical team was made up of 3 other senior-level software engineers. The software for the most advanced model (the color 1050) comprised 17,000 lines of C code representing 506 functions and generated 100K of real-time embedded firmware controlling a 68000 family microprocessor. All three products were completed on schedule and underwent extensive automated software testing (test code comprised 37,000 lines of C). After shipping nearly ten thousand Touch Control Screens, no software upgrades have ever been necessary.

Software Engineer: Fluke BASIC Interpreter (1982 - 1983)

Sole software engineer charged with porting a BASIC interpreter from a limited-memory model (64K) to an extended-memory model. This work involved modifying data structures and algorithms to provide for longer addresses as well as conversion of logical addressing to physical addressing via a memory mapper.

Vice President and Director of Engineering: Garland-Parle Mfg. Co., Inc. Talking Depth Sounder models 500, 510, 520, & 530 (1981 - 1983)

Co-founded a company to develop the world's first family of talking depth sounders. After doing all the software and hardware design, our two-person company manufactured and sold 80 units before selling the engineering rights to Coastal Navigator, Inc. of Seattle. I received considerable sales/marketing exposure during this experience as I was responsible for successfully convincing major wholesale marine equipment distributors to carry our line of products. After 12 years, no software upgrades have ever been needed.

Design Engineer: Fluke 2280 Datalogger (1979 - 1982)

One of four software engineers working on the software for this integrated datalogging system. My responsibilities included the design of all math-related software. This software effort included software math routines for the main processor card, math coprocessor software for the advanced math option board, and a mathematical expression parser, all running under a custom multi-tasking kernel. I completed my responsibilities through design review before leaving to co-found my own company (see above).


Hardware Design Consultant: - previously Traveling Software (March 1992 - May 1992)

Evaluated the design of a new low-cost RF-modem as a wireless extension from an enterprise-wide network backbone. Designed alternative hardware implementations for packaging the modem as an extension to an PC-based network. Designs were based upon high-speed microcontrollers and were optimized for size, cost, and power consumption since one target implementation was a PCMCIA card. (See software experience for related software work.)

Design Engineer: Fluke 17XX-006/007/008/009 Dynamic Ram Memory Option (1983 - 1984)

I designed the dynamic RAM memory option board for the Fluke 1722 Instrument Controller. This single design was configurable for 4 sizes of memory. The design included the use of PALs, state machines, and a detailed timing analysis. The design was so successful that we skipped the normal third revision during development and entered production ahead of schedule. The design has been successfully shipping since 1984 without modification.

Design Engineer: Fluke 1722 Single Board Computer (1983)

One of three engineers designing the CPU board within the Fluke 1722 Instrument Controller. My portions included a high speed "macrostore" (a cache for custom instructions), the floppy disk interface, and exception handling logic. The design has been successfully shipping since 1983.

Vice President and Director of Engineering: Garland-Parle Mfg. Co., Inc. Talking Depth Sounder models 500, 510, 520, & 530 (1981 - 1983)

See SOFTWARE EXPERIENCE:. Designed and implemented the software for a talking depth-sounder mentioned in the section above. I designed all the hardware as well as the software for this family of talking depth sounders. The design was based upon an Intel 8039 microprocessor and the "Digitalker" voice synthesis chip-set by National Semiconductor.

Associate Design Engineer: Fluke 2280 Datalogger Advanced Math Coprocessing Board (1979 - 1982)

My first design experience after leaving school was based upon a Z80 microprocessor and an AMD math-processing chip. The coprocessor board performs all advanced math operations within the Fluke 2280 datalogger.