WorksPhysics and Astronomy
OASIS-UROS: Open Acquisition System for IEPE Sensors – Upgraded, Refined, and Overhauled Software
Abstract
OASIS-UROS continues the previously published Open Acquisition System for IEPE Sensors (OASIS). While still building on the ESP32 microcontroller, this version improves the overall performance by switching to an SD card caching system and upgrading the analog-digital converter to an AD7606C-18, which has a higher resolution, provides eight channels, oversampling, and software-adjustable voltage ranges. Also improved is the IEPE front-end and power supply, as well as the firmware of the acquisition system, which can now achieve a sample rate of up to 36 kHz while sampling all eight channels. This paper documents the hardware and software of OASIS-UROS and provides all materials required to reproduce the open acquisition system. Lastly, the system was validated against commercial hardware and software in an experimental modal analysis context. This showed that the system performs close to the commercial one in some aspects with respect to the utilized test case. While OASIS-UROS cannot match the full performance of the commercial system, the developed system can be a viable alternative for students, people in academia, or smaller companies that have a constrained budget or require complete insight as well as adaptability of the hardware and software.
Specifications table
| Hardware name | OASIS-UROS |
| Subject area | Educational tools and open source alternatives to existing |
| Hardware type | Measuring physical properties and in-lab sensors |
| Closest commercial analog | OROS MODS OR10-DAQ-8 or similar compact acquisition systems with 8 IEPE channels and compact form factor |
| Open source license | CC-BY 4.0 (Hardware) / MIT (Software) |
| Cost of hardware | $220 / 200 € |
| Source file repository | At time of publication: https://doi.org/10.5281/zenodo.13763227 [1]<br>Most current version: https://gitlab.com/oasis-acquisition |
| OSHWA certification UID | DE000150 |
Table 1.
Hardware in context
Driven by advancements in structural health monitoring, predictive maintenance, and industrial automation, the demand for data acquisition systems for vibrational sensor signals is steadily increasing with extremely different requirements. The OASIS-UROS data acquisition system is built around an ESP32-S3 microcontroller and an AD7606C-18 ADC, optimized for capturing high-fidelity vibration data from IEPE (Integrated Electronics Piezo-Electric) sensors. This design reflects a trend in open-source hardware platforms that combine affordability, flexibility, and accessibility for specialized data acquisition tasks. OASIS provides users with the ability to record multi-channel, high-resolution analog data, making it suitable for vibration analysis applications, scientific research, and teaching.
It is important to properly position the system presented in this article in terms of its capabilities and limitations within the field of existing systems. A distinction is made between proprietary and open-source solutions. We see the system as somewhat of a bridge between expensive high-end systems and very simple DIY solutions.
OASIS is a fraction of the proprietary systems’ cost, making it attractive to users with more budget constraints or those looking for a lightweight, customizable system for smaller-scale applications.
Comparison to Proprietary Systems
Comparing OASIS-UROS to established proprietary systems reveals significant differences in capabilities, scalability, and user experience. Many companies offer well-designed hardware. The big differences unveil in their software capabilities.
National Instruments - CompactDAQ The CompactDAQ (cDAQ) platform from National Instruments supports a range of sensor modules, including IEPE inputs, with resolutions up to 24-bit. It is highly modular, with support for various I/O configurations and scalable across multiple modules. The system integrates with National Instruments’ LabVIEW for data acquisition and processing, but its reliance on LabVIEW limits cross-platform flexibility. cDAQ offers Python APIs for external access but remains tethered to Windows for full functionality. Hardware costs for IEPE channels are approximately 500 USD per channel.
Brüel & Kjær - LAN-XI Brüel & Kjær’s LAN-XI system is built for precision data capture with support for multiple IEPE channels, offering configurable input ranges and digital filters to improve signal integrity. LAN-XI modules provide up to 24-bit resolution and are optimized for environments requiring robustness, such as field testing. However, LAN-XI is proprietary, limiting user-level customization and requiring a significant upfront investment for hardware and software.
Siemens LMS - SCADAS Siemens LMS SCADAS systems provide high channel counts with 24-bit resolution and sampling rates up to 500 kSps, suitable for large-scale vibration testing. SCADAS hardware supports synchronized data acquisition across multiple sensor types, with real-time processing capabilities. A modular, extensive software package is available which offers direct support for Experimental Modal Analysis (EMA), Operational Modal Analysis (OMA), or Transfer Path Analysis (TPA).
Müller BBM - PAK The PAK system offers high-resolution data capture with flexible channel configurations. PAK supports real-time signal processing and is used primarily for acoustic and vibration testing.
HBM QuantumX HBM’s QuantumX is a modular system for data acquisition with support for high precision measurement across different input types, including IEPE. The system features 24-bit resolution and sampling rates up to 100 kSps. QuantumX modules are well-suited for high-end industrial and experimental setups. Its strength lies in precise synchronization across multiple modules and high channel scalability.
Dewesoft - Sirius Mini The Sirius Mini is a compact data acquisition unit offering up to 24-bit resolution with configurable input channels. Dewesoft’s system is designed for portable applications but retains high precision through its use of DualCoreADC technology. Despite its compact form factor, Sirius Mini remains a high-cost solution, focused more on portability.
OROS A French company offering systems optimized for dynamic signal analysis in the field of vibrations. OROS hardware is mobile, rugged and supports a range of input types, including IEPE. OROS provides application oriented software packages for EMA and OMA. The price range is in the high-end region.
Goldammer GmbH Goldammer GmbH offers a compact IEPE measurement system designed for precision data acquisition in industrial and laboratory environments. The system supports multiple IEPE channels with 24-bit resolution and sampling rates up to 200 kSps. The system is designed for use with API access for integration with external platforms like MATLAB and Python. Integration is provided for DaisyLab and LabView. Though not open-source, the hardware is built for reliability and accuracy in demanding applications, while providing flexibility for custom software development through its API. Pricing is competitive within the mid-range market, positioning it as a more affordable alternative to higher-end proprietary systems.
Comparison to open-source solutions
To the authors’ knowledge there is no complete open source (hardware and software) IEPE data acquisition system available. A few interesting products are listed below. However, they all aim at different use-cases.
MCC 172 DAQ Hat for Raspberry Pi The MCC 172 DAQ Hat provides two IEPE channels with 24-bit resolution and sampling rates up to 200 kSps, designed for integration with the Raspberry Pi. While the driver software is open-source, the hardware remains proprietary, limiting further customization. Its compact form factor and low cost make it a viable option for small-scale projects, though its performance is constrained by the limitations of the Raspberry Pi platform. The DAQ-Hat is available for 500 USD without the Raspberry Pi.
Analog Devices IEPE Data Acquisition Reference Design Analog Devices offers a reference design for a 4-channel, 24-bit, 256 kSps IEPE data acquisition system, featuring the AD7768-4 chip. The design is high-end and provides open schematics but lacks an open-source firmware, limiting its flexibility for custom implementations. The system provides high accuracy and precision but is more suited as a starting point for custom system development than a ready-to-use platform. A development kit is available for 900 USD. This system is the closest to the OASIS-UROS design.
OpenDAQ The OpenDAQ is an early days (2008) data acquisition project with a PC/104 (ISA) interface, 16 DIO (digital I/O) ports, and 8 ADC (Analog-to-Digital Converter) inputs. Unfortunately, the last update seemed to be available from 2008.
Conclusion
In conclusion, the market offers a variety of well-designed hardware solutions for data acquisition, but the critical differentiator among them lies in the software capabilities they provide. Over the past few years, open-source software for structural dynamics has gained significant momentum, exemplified by projects like pyFBS [2], which empower users with flexible and customizable tools for analysis. This trend underscores the importance of open-source hardware, as it presents an opportunity to further strengthen the community and enhance the dynamics of open-source structural analysis tools. Now is an opportune moment to invest in open-source hardware development, as it can drive innovation, facilitate collaboration, and provide researchers and practitioners with the accessible resources needed to advance the field of structural health monitoring and analysis.
Hardware description
OASIS-UROS is based around the Analog Devices AD7606C-18 analog-digital-converter (ADC), providing a high quality analog-digital conversion, and the Espressif ESP32-S3 micro-controller, controlling the data flow. In contrast to traditional DAQ-systems, no FIFO-buffer is used to save costs, space and complexity. A main feature of the board is the on-board IEPE power supply using the MC34063 series boost-converter and LT3092 constant current sources. This allows the board to solely operate using a 5V USB power supply.
A detailed scheme of the 4-layer PCB with the key hardware components is depicted in Figure 1.

Figure 1. Overview of the OASIS-UROS board
The - provides 8 simultaneously sampled channels with individually selectable input ranges. Its integrated analog front end with programmable over-sampling significantly reduces external component count and noise. Each channel is equipped with an acquisition front-end on the - board consisting of a constant current source build using chips. The IEPE source current can be tuned individually for each channel using a potentiometer. All input signals pass a fixed, passive high-pass RC-filter with a dB cutoff frequency of 0.8 Hz. This means, always operates in AC mode. To avoid hidden costs, provides BNC connectors directly on the board, i.e., no adapters are needed, and standard sensor equipment can directly be used.
The interface between ADC and micro-controller is designed such that the ADC is read in data parallel mode, i.e., 8 data lines are connected to one GPIO register of the microcontroller, refered to as Octal SPI. This means, during one read clock cycle, one bit of all 8 channels is read simultaneously. As each channel provides 18-bit resolution, 18 read cycles are necessary to capture all data. Details about the software implementation are described in the next section.
The - includes a - co-processor, running at 17.5 MHz which also has access to the GPIO registers. This would allow the outsourcing of the data transfer into the RAM utilizing the co-processor while the main-processor can still be available for user-communication. The authors, however, did not test this approach. Similarly, the - includes WiFi connectivity that could be used to acquire sample data wirelessly, as was possible with the original version [3]. Since major parts of the original firmware were rewritten and adjusted, wireless sampling is not yet available with -.
Firmware description
The firmware for the systems is written in C++ using the Arduino IDE. This code runs on the - microcontroller and is mainly responsible for controlling the - ADC as well as retrieving the sampled voltage values. The firmware provides an abstraction layer for the user, allowing the hardware to be controlled using high-level commands. Besides requesting sampling, this might be, for instance, configuring the voltage ranges using OASIS.SetVoltageRange(). All available commands are documented in the Command Reference, found in appendix § 12. While it is possible to control the system manually using the commands provided, using the -, a graphical user interface written in Python, is recommended. Details can be found in operating instructions in § 8.
When the system is powered on, it reads the device information stored in the EEPROM (refer to the command reference in appendix § 12) and displays this information via the Serial interface. This information is also used for the - to properly handle the sample conversion process described later. Setting this information is described in § 8. Besides this, feedback is provided about device operations and whether they were successful. For example, when no SD card is detected, this will be displayed in the startup messages.
OASIS Serial Interface - Startup Sequence
[OASIS] Open Acquisition System for IEPE Sensors starting up...
------------------------------------------------------------------------------
OASIS Device Information
------------------------------------------------------------------------------
[OASIS] Device Architecture is OASIS-UROS (ID 1)
[OASIS] Device Hardware Version is 1.1
[OASIS] Device Firmware Version is 2.0
[OASIS] ADC resolution: 18
[OASIS] TEDS module installed (1=yes, 0=no): 0
[OASIS] WSS module installed (1=yes, 0=no): 0
[OASIS] Device name: OASIS-UROS Alpha
[OASIS] Current device configuration: MUTE: 1, WIFI_EN: 1
------------------------------------------------------------------------------
[OASIS] Resetting ADC...
[OASIS] Setting ADC data out format to 8 lines...
[OASIS] Successfully written 0x18 to address 0x2
[OASIS] Setting voltage range to +/- 2.5V for all channels...
[OASIS] Setting voltage ranges in ADC...
[OASIS] Successfully written 0x0 to address 0x3
[OASIS] Successfully written 0x0 to address 0x4
[OASIS] Successfully written 0x0 to address 0x5
[OASIS] Successfully written 0x0 to address 0x6
[OASIS] Voltage ranges set.
[OASIS] Setting oversampling factor x4 in ADC...
[OASIS] Successfully written 0x2 to address 0x8
[OASIS] Oversampling factor set.
[OASIS] Initializing SD Card...
[OASIS] Detected SD card with 60350MB total space.
[OASIS] Used space: 241MB /29968MB partitioned space.
[OASIS] Free space: 29726MB.
[OASIS] Finished booting.
In the previous version of the OASIS firmware, used for the original OASIS board [3], commands can be sent to the system either with a wired connection using the USB-C port and the Serial interface or wirelessly using WiFi and UDP packets. Due to the major rewrite of the firmware, this functionality is not yet available for the OASIS-UROS firmware but is planned for future releases.
Reading the sampled values from the ADC in real time and storing them for later use is the most time critical step of data acquisition. The less computation time is required, the faster data can be sampled. Ideally, all samples retrieved from the ADC would just be kept in random access memory (RAM) and processed afterward. However, this is not possible due to the limited RAM of the ESP32-S3, which is only 512 kB. For eight channels with 18-bit data per sample each, only around 28400 samples can be stored in total, assuming the whole RAM could be used.
For this reason, the acquired data is cached on an SD card during the data acquisition, effectively allowing for unlimited sampling time, given that microSD cards with large storage capacity are readily available. The sampled data is cached on the microSD card in a raw and unsorted format and post-processed afterward. This is in contrast to the previous OASIS version detailed in [3], where the samples were sent out during the sampling procedure. For convenience, the sampled data can still be transmitted via the Serial interface after the sampling process is completed, e.g., to check signal levels or double impacts. An overview of the fundamental routines is given in the state diagram in Figure 2.

Figure 2. State diagram of the OASIS firmware depicting the standard sample procedure
If the system is controlled manually, the user should note that voltage ranges and oversampling values are not set using the OASIS.Sample() command, but have to be configured before with the appropriate commands. During the system initialization, all voltage ranges are set to V and the oversampling factor to x4. Further, the ADC is configured to use eight data out lines to send the sampled data to the microcontroller.
Of interest to all users are the files created by OASIS on the SD card. When invoking the OASIS.Sample() command, a file name has to be specified, e.g., TestFile. All files belonging to this sample will have this name. The first file created is a metadata file (.OASISmeta) containing all relevant acquisition configurations, e.g., sampling frequency, voltage ranges, device name. Next is the file containing the unprocessed bits of the sample (.OASISraw). This file is usually not required anymore after the sample has been processed by OASIS. The sorted data is saved in a file ending with .OASIShex containing the sampled bits in the raw format expected by the OASIS-GUI. An example usage is given below, where the user enters their commands as follows:
OASIS Serial Interface - Example Commands
> OASIS.SetVoltageRange(2,2,3,3,4,4,5,5)
> OASIS.SetOversampling(2)
> OASIS.Sample(10,32000,0.1,0,TestFile)
Those commands can either be issued using a serial interface, e.g., using the Serial Monitor of the Arduino IDE or by sending the commands as UDP packets. First, the voltage ranges are set with the corresponding ID (found in the command reference in appendix § 12) to V for the first two channels, V for channel 3 & 4, V for channel 5 & 6 and V for the last two channels. Then, the oversampling factor is configured to x4, and the sampling is started for 10 s with a sampling rate of 32 kHz when the first channel surpasses the set trigger level of 0.1 V. The results of the sample are saved in files named TestFile, and the corresponding metadata file contains the following:
TestFile.OASISmeta
1 t_sample,10.00;f_sample,32000.00;n_sample,320000;trigg-level,0.10;sync_mode,0;
ADC_BITS,18;VoltageRangIDS,2,2,3,3,4,4,5,5;VoltageRanges
,5.00,5.00,6.25,6.25,10.0,10.0,12.5,12.5;OversamplingFactor,x4;
DeviceArchitecture,OASIS-UROS;DeviceName,OASIS-UROS Alpha;
Note that the sync_mode field is a feature of the original OASIS board and is not available at this time for OASIS-UROS, but this option is kept for future releases. The sampled data can now be retrieved from the .OASIShex file on the SD card or using the OASIS-GUI, detailed in § 8.
The procedure of retrieving samples from the ADC and saving them to an SD card in real time is further detailed below. Further, the required logic to obtain the voltage values from the sample bits, and how the sampled data can be accessed for further usage is detailed. Lastly, the differences between normal sampling mode and triggered sampling, when a user-definable voltage level is exceeded, are explained.
Retrieving individual samples from the ADC
The logic required to acquire one sample, consisting of one voltage value quantized using 18-bit for each of the eight channels, is depicted in Figure 3. This timing diagram, based on the ADC datasheet [4], shows the logical values, either zero or one, of the pins listed on the left, e.g., ADC_CONVST.

Figure 3. Timing diagram of ADC sampling routine depicting logical values of pins over time, based on [4]
The sampling routine starts by requesting the ADC to sample the voltage currently applied to its input pins, which is achieved by setting ADC_CONVST to HIGH. This transition is controlled by a hardware-generated PWM signal of the ESP32-S3 configured with the sampling frequency requested. After receiving the command to start the sampling process, the ADC will read the voltages on its input pins. During this time, the ADC signals that it is processing the sample by setting the ADC_BUSY pin to HIGH.
One advantage of using a hardware-generated PWM signal instead of a timer, as used by the original OASIS firmware, is a reduced jitter of the sample points. This is because timer interrupt service routines are scheduled by FreeRTOS, and thus, the time when ADC_CONVST is actually set to HIGH can vary. FreeRTOS does not have to interact with the PWM signal. Further, with a timer interrupt the window to process samples would be between the falling ADC_BUSY and the rising ADC_CONVST, since the timer interrupt would interfere with reading the samples. Using PWM, the window increases to the time between two falling edges of ADC_BUSY and effectively decouples the processing of the ADC and the ESP32-S3, i.e., both can take almost the whole sample period to process. This allows for a higher oversampling factor to be set, increasing the signal-to-noise performance.
When the sample is ready, the ADC will transition the ADC_BUSY pin to LOW. On this falling edge, a GPIO interrupt of the ESP32-S3 will be triggered that starts the process of reading the data lines into RAM using OctoSPI, an SPI implementation using eight data lines simultaneously. First, the chip select ADC_CS is set to LOW to initiate the transaction. The falling edge of ADC_CS leads to the ADC providing the most significant bit (MSB) of the sample on the data out lines. In Figure 3, the MSB is denoted by DB17, i.e., the 18th bit of the sample, where the MSB of channel 1 can be read from ADC_DOUT1, for channel 2 on ADC_DOUT2 and so on.
The custom function byte OASISDRIVER::readADCByte() is used to read the values of the data out lines. At first, the clock ADC_SCLK is set to low, which does not change the bits provided by the ADC. After this, the 32 bit of the first GPIO input register GPIO_IN_REG of the ESP32-S3 is read, see also the technical reference manual of the ESP32-S3 [5]. The value of ADC_DOUT1 (GPIO1) is contained at the second least significant bit (LSB), ADC_DOUT8 (GPIO8) is the ninth LSB. Using a bit-wise AND with the appropriate bit mask 0x1FE, followed by a bit-wise right shift of one, yields the desired eight bits, i.e., the first byte of the sample, see also Figure 4.

Figure 4. Illustration of ADC sample extraction from the GPIO input register GPIO_IN_REG of the ESP32-S3; marked in blue are the desired ADC sample bits
At the end of the custom function, the clock ADC_SCLK is set back to HIGH, which signals the ADC to provide the next bits (DB16) on the data out lines.
This process is repeated until all eight bits of each channel, resulting in a sample size of 18 bytes, are retrieved. At the end, the chip select ADC_CS is returned to HIGH, restoring the same logical levels as at the beginning of the sample procedure and the system waits for the next timer interrupt.
Real-time sample acquisition and storage
Only crucial processing steps are performed to minimize the time spent processing the ADC samples during the data acquisition. Additionally, the second core of the ESP32-S3 is utilized. The main code, i.e., the Arduino sketch, by default runs on core 1, while core 0 handles all network-related code, e.g., the WiFi access point. This means that this core is shared with other tasks and is not suited for time-critical task, like retrieving samples from the ADC. However, it can be used for less critical tasks, like moving data to the SD card. This is the basis for the utilized sample data handling, see also Figure 5.
Figure 5. Illustration of ADC sample transfer concept
The data from the ADC is stored in RAM in one of two arrays used for caching, OASISCacheA or OASISCacheB. Which cache is used is controlled by the variable CachePage that keeps track of how many caches have been filled and is initialized to 1. If the number is odd, i.e., the value of CachePage is not dividable by 2 and CachePage%2 = 1, the data is written to OASISCacheA. If CachePage is odd, then OASISCacheB is used.
The position in the cache where the next sample should be written to is tracked using the variable CacheIndex, which is incremented by 1 after a new sample (18 bytes) has been written. When the last available position has been written to, the CacheIndex is reset to 0, and CachePage increased. Core 1 now saves new samples in the other cache, e.g., OASISCacheB, allowing core 0 to access the cache previously written to, e.g., OASISCacheA. At this point, core 0 is signaled to start writing data to the SD card by setting PacketToWrite to true.
The CACHE_SIZE is chosen to be relatively large to reduce the overhead of writing to the SD card, e.g., from having to rewrite all data within one block. The only time constraint for the data write task is that it has to finish writing the cache to the SD card before core 1 fills the next cache page. Short interruptions by other tasks running on core 0 are therefore okay. When core 0 finishes writing the data, it acknowledges this by setting PacketToWrite to false. This also serves as a collision check. In case core 1 filled the next cache page and PacketToWrite is set to true, core 0 did not finish in time. Then, the sampling process is terminated, and an error is thrown, informing the user that the sample rate is probably too high.
The last and only partially filled cache page is handled at the end of the sample procedure. Using the variable WriteLastPacket, core 0 is informed to write the remaining data to the SD card, then the file handle is closed. Next, the samples written on the SD card are post-processed as described below.
Post-processing of samples
After sampling, the samples are cached on the SD card in a .OASISraw file, written in the same order as they were acquired. For post-processing, one sample, i.e., the data of all eight channels at one moment in time, consisting of 18 bytes, is read into RAM. Then, the first bit in this chunk is the MSB (DB17) of channel 8, followed by the MSB of channel 7, etc., refer also to Figure 6.
Figure 6. Illustration of assembling the ADC data sorted by channel (.OASIShex) from sampled bits (.OASISraw)
Two operations must to be performed to sort the data chunk into a usable format, i.e., where all bits belonging to one channel are consecutive and the channels are ordered from one to eight. First, the channels are separated into individual 32 bit variables, where the bits are moved to the correct positions, e.g., the MSB is bit 17. Then, to write the data back to the SD card, the channels are written into an 18 byte write cache, where the first byte contains DB17 through DB10 of channel 1, the second byte DB09 through DB02, and so on. The data formatted like this is written into the .OASIShex file. Even when the samples would be sent over the serial interface directly during the conversion process, this process is still necessary to maximize transfer speeds. Otherwise, the channel data would have to be zero-padded to 3 bytes, i.e., 24 bit, for the transfer. Since the sorting procedure is relatively simple, this is still done on the ESP32-S3 microcontroller. Using the Serial interface, the samples are transferred to a computer after sorting.
When the OASIS-GUI is used, the samples are automatically converted into voltage values. For this, the bytes are sorted by channel again and buffered in a Numpy array OASISChannelData with dimension of number of samples by 8. The algorithm to convert the ADCCode, i.e., the sorted bits of each sample and channel, is based on the ADC transfer function for bipolar input (positive and negative values) depicted in Figure 7.
Figure 7. Transfer function between the analog input voltage and ADCCode, based on [4]
As can be derived from the figure, the first bit (MSB) is the sign bit, i.e., denotes whether the voltage is positive (MSB=0) or negative (MSB=1). The remaining bits indicate the magnitude of the voltage, where for MSB=0 all other bits equal to zero denotes a voltage of zero, and all bits equal to one denotes the positive full-scale (PFS) value, e.g., 2.5 V for a voltage range of ±2.5 V. For negative values (MSB=1), all other bits equal to zero indicate the negative full-scale (NFS), e.g., −2.5 V. Therefore, the measured voltage is given by:
To correctly convert the ADCCode to voltage, PFS and NFS must match the voltage range set for each channel. When the OASIS-GUI is used to retrieve the samples, the required information was entered into the GUI and is known. In case .OASIShex files should be converted to voltages at a later point in time, the .OASISmeta file is required because it contains all parameters used for the data acquisition. Lastly, the time vector can be reconstructed using the sampling frequency and duration.
Triggered sampling
When a trigger is used to start the sampling process, there are a few differences that are described in this section. To capture the data before the sampling starts, i.e., the pre-trigger data, the system is continuously samples data after the command has been invoked. The sampled data is written into a third cache OASISCachePre, that is smaller than the caches used for sampling. The position within the cache is tracked using the variable PreCacheIndex. When the end of the cache is reached, PreCacheIndex is set back to zero, and the first data sampled is overwritten. This means that the system can remain in pre-trigger mode indefinitely, but also that the pre-trigger data is limited to as many samples as can fit into OASISCachePre. The size is defined in the firmware using PRECACHE_SIZE, which is set to 1000 by default. Since the number of samples is fixed, the temporal length of the pre-trigger data will vary with the sample rate. Especially for low sample rates, the user must wait for the OASISCachePre to fill with data, otherwise, useless data is included in the samples.
To determine when the sampling process should start, defined by the user as a voltage level trigg_level that channel 1 has to surpass, the samples of channel 1 are assembled and converted to voltage while sampling. When the set level is exceeded, the normal sampling procedure begins and ends with the transmission of the sorted bytes after the trigger. The pre-trigger data is sent after this data.
First, the pre-trigger data is written to the SD card in the file \*_PRE.OASISraw, where * is the filename provided in the OASIS.Sample() command. Since PreCacheIndex holds the last index in the OASISCachePre that was written to, writing the data in the corrected order can be done in two steps. First, the data starting at PreCacheIndex+1 until the end is written, where OASISCachePre+1 is the oldest sample. Second, the data from the beginning of OASISCachePre until PreCacheIndex is written. The file \*_PRE.OASISraw is now in the correct temporal order, i.e., from oldest to newest sample, but still has to be post-processed as described above. Using the same procedures, the bits are sorted into \*_PRE.OASIShex and sent over the Serial interface.
Design files summary
A summary of the provided design files is provided in the table below.
| Design filename | File type | Open source license | Location of the file |
| oasis-uros-hardware.zip | KiCad project | CC-BY 4.0 | https://doi.org/10.5281/zenodo.13763227 [1] |
| jlcpcb_manufacturing_files.zip | JLCPCB manufacturing files | CC-BY 4.0 | https://doi.org/10.5281/zenodo.13763227 [1] |
| oasis-firmware.zip | Arduino source code | MIT | https://doi.org/10.5281/zenodo.13763227 [1] |
| oasis-gui.zip | Python package | MIT | https://doi.org/10.5281/zenodo.13763227 [1] |
| bottom_case.stl | STL file for 3D printing | CC-BY 4.0 | https://doi.org/10.5281/zenodo.13763227 [1] |
Table 1 (PDF p. 13). Summary of design files provided in the repository
oasis-uros-hardware.zip This archive contains the full KiCad1 project of the OASIS-UROS board as described here. Included are the KiCad schematics, the KiCad PCB, and all required symbols and footprints.
jlcpcb_manufacturing_files.zip Included here are the production files used by JLCPCB to fabricate the partially assembled board. Using those files, the same board as used for validation can be ordered.
oasis-firmware.zip In this archive, the source code for the board firmware can be found. OASIS-Firmware.ino is the main code file; the other files are supplementary files. The code needs to be compiled using the Arduino IDE2.
oasis-gui.zip For archival purposes the source code for the OASIS-GUI is included in the design files. However, it is recommended that the current version from the Python Package Index is installed using pip install OASIS-GUI3.
bottom_case.stl Lastly, for protection against mechanical damage, shielding the bottom of the finished board is recommended. A 3D printing file for a simple case is included with this file.
Bill of materials summary
Due to the size of some components, it is recommended to have the PCB at least partially assembled by the manufacturer. For the OASIS-UROS board, we provide manufacturing files for JLCPCB that describe such a partially assembled board. This board can then be fully assembled as described in the build instructions. Following this approach, the table below lists all required components.
| Designator | Component | Number | Cost per unit - currency | Total cost - currency | Source of materials | Material type |
| PCB | Printed & partially assembled circuit board | 1 | ≈ $35 | ≈ $35 | JLCPCB | Other | |
| X1-X4 | Amphenol 031-6578 | 4 | $14.25 | $57.00 | 523-31-6578 (Mouser) | Metal | |
| ADC0 | AD7606C-18BSTZ | 1 | $51.35 | $51.35 | 584-AD7606C-18BSTZ (Mouser) | Semiconductor | |
| U50-U57 | LT3092EST | 8 | $5.79 | $46.32 | 584-LT3092EST#TRPBF (Mouser) | Semiconductor | |
| VR1-VR8 | 3296Y-1-203LF | 8 | $2.42 | $19.36 | 652-3296Y-1-203LF (Mouser) | Semiconductor | |
| C40, C41 | MAL215099103E3 | 2 | $2.33 | $4.66 | 594-MAL215099103E3 (Mouser) | Semiconductor | |
| L40 | SRR1260A-471K | 1 | $0.78 | $0.78 | 652-SRR1260A-471K (Mouser) | Semiconductor | |
| LS1 | PS1420P02CT | 1 | $0.75 | $0.75 | 810-PS1420P02CT (Mouser) | Semiconductor | |
| JP1-JP8 | Jumper & Pinheaders | 8 | $0.23 | $1.84 | 571-28815452 (Mouser) | Other |
Table 2. Bill of materials summary using partially assembled PCB
If a preassembly by the manufacturer is not desired, the table below lists the additional required components. Generic capacitors and resistors are not listed in the table below.
| Designator | Component | Number | Cost per unit - currency | Total cost - currency | Source of materials | Material type |
| U1 | ESP32-S3FN8 | 1 | $3.2415 | $3.2415 | C2913196 (JLCPCB) | Semiconductor | |
| U40 | MC34063 | 1 | $0.0881 | $0.0881 | C5349988 (JLCPCB) | Semiconductor | |
| U80 | USBLC6-2P6 | 1 | $0.0974 | $0.0974 | C2827693 (JLCPCB) | Semiconductor | |
| U90 | TLV76733DRVR | 1 | $0.2439 | $0.2439 | C2848334 (JLCPCB) | Semiconductor | |
| LED1-LED10 | WS2812C-2020-V1 | 10 | $0.0626 | $0.626 | C2976072 (JLCPCB) | Semiconductor | |
| D40 | 1N5819HW-7-F | 1 | $0.0279 | $0.0279 | C82544 (JLCPCB) | Semiconductor | |
| F1 | JK-nSMD050-30 | 1 | $0.03 | $0.03 | C720075 (JLCPCB) | Semiconductor | |
| Y100 | SX2B40.000F1210F30 | 1 | $0.0993 | $0.0993 | C2901733 (JLCPCB) | Semiconductor | |
| AE1 | RFANT3216120A5T | 1 | $0.0654 | $0.0654 | C127629 (JLCPCB) | Semiconductor | |
| T70 | DDTC114YCA-7-F | 1 | $0.0273 | $0.0273 | C57530 (JLCPCB) | Semiconductor | |
| SW1-SW3 | TS-1101-C-W | 3 | $0.0348 | $0.1044 | C318938 (JLCPCB) | Semiconductor | |
| J200 | U.FL-R-SMT-1(80) | 1 | $0.0816 | $0.0816 | C88374 (JLCPCB) | Semiconductor | |
| J4 | BM04B-SRSS-TB(LF)(SN) | 1 | $0.1579 | $0.1579 | C160390 (JLCPCB) | Semiconductor | |
| J5 | GT-TF003-H0185-02 | 1 | $0.1272 | $0.1272 | C5155564 (JLCPCB) | Semiconductor | |
| J80 | GT-USB-7010ASV | 1 | $0.0759 | $0.0759 | C2988369 (JLCPCB) | Semiconductor |
Table 3. Summary of additionally required components when using bare PCB
Build instructions
Using the provided design files, it is possible to have the acquisition board printed and fully assembled by the PCB manufacturer. However, there might be some minimum order quantities or issues with the availability of non-standard components. In this case, ordering an only partially assembled PCB, where only cheap and/or standard parts are placed, might be preferred. Using the manufacturing file provided for JLCPCB4, such a partially assembled PCB, as depicted in Figure 8, can be ordered.

Figure 8. Partially assembled PCB using the provided JLCPCB manufacturing file (right) and recommended voltage supply rail testpoints TP1, TP2 (left)
Preliminary checks Before connecting the board to a PC, it is recommended to check the USB voltage rail for shorts to ground. For this, the resistance between testpoint TP1 (, 5 V) to the chassis of the USB plug can be tested. Similarly, the output of the 3.3 V supply can be tested for shorts using TP2 (, 3.3 V). If no shorts exist, the board can be connected to power via a USB-C cable, and TP1 as well as TP2 can be checked for the expected voltages. Note, that the USB specification allows for to be between 4.75 and 5.25 V [6].
Then, the next step is to burn the bootloader for the ESP32-S3 microcontroller and flash the OASIS firmware. Those steps are detailed in § 7.1. If the board was ordered fully assembled, the steps after § 7.1 can be skipped until the current calibration, as described in § 7.5. Otherwise, following the steps outlined below that detail how to assemble the PCB is recommended.
Burning the bootloader and flashing the firmware
To burn the bootloader and flash the firmware, the Arduino IDE5 must be installed. Then, installing the board library ’esp32’ by ’Espressif Systems’ for the ESP32 family microcontroller through the Boards Manager tab in the left column might be required. The software was developed and tested with version 3.0.3. Finally, one third-party library, ’Adafruit NeoPixel’ by ’Adafruit’, must be installed (tested with version 1.12.3).
After connecting the board to the PC with a USB-C cable, two settings must be selected before flashing the firmware. First, from the menu bar, ’Tools’ → ’Board’ → ’esp32’ → ’ESP32S3 Dev Module’ has to be selected. In the same menu, ’USB CDC On Boot’ has to be set to ’Enabled’, otherwise, there is no serial communication. Then, the firmware can be uploaded. If this is successful, the LED startup sequence, where the channel LEDs one through eight get lit in sequence, should play. Since there is no ADC, the communication with it fails and the system goes into an error state, signaled by a red blinking Status LED. When opening the ’Serial Monitor’ (serial speed of 1,000,000 baud), the following output should be visible:

Figure 9.
Soldering the ADC
First, the ADC is soldered to the board since this is the most difficult part to solder due to the small footprint. The correct orientation of the ADC is shown on the left hand side of fig. 9. On the right hand side, the pinout of the ADC is shown for reference. Since some pins share the same signal, e.g., the three ground pins in the upper pin row on the left, some solder bridges between the pins might be okay. Using a drag soldering technique for the ADC and inspecting the pins for unwanted shorts under a microscope is recommended.

Figure 9 (PDF p. 18). Assembly step 1: Soldering the ADC ADC0, pinout shown on the right for quick reference
Check of ADC When connecting the board to the PC again, the following output should be displayed. As can be seen, for instance from [OASIS] Successfully written 0x18 to address 0x2, the communication with the ADC works as expected. If this is not the case, then there are some hardware defects.
OASIS Serial Interface - Startup Sequence
[OASIS] Open Acquisition System for IEPE Sensors starting up...
[...]
[OASIS] Resetting ADC...
[OASIS] Setting ADC data out format to 8 lines...
[OASIS] Successfully written 0x18 to address 0x2
[OASIS] Setting voltage range to +/- 2.5V for all channels...
[OASIS] Setting voltage ranges in ADC...
[OASIS] Successfully written 0x0 to address 0x3
[OASIS] Successfully written 0x0 to address 0x4
[OASIS] Successfully written 0x0 to address 0x5
[OASIS] Successfully written 0x0 to address 0x6
[OASIS] Voltage ranges set.
[OASIS] Setting oversampling factor x4 in ADC...
[OASIS] Successfully written 0x2 to address 0x8
[OASIS] Oversampling factor set.
[OASIS] Initializing SD Card...
E (5686) sdmmc common: sdmmc init ocr: send op cond (1) returned 0x107
E (5687) vfs fat sdmmc: sdmmc card init failed (0x107).
[OASIS] FATAL ERROR - Failed to mount SD card!
[OASIS] FATAL ERROR - Critical self check failed!
Assembly of boost converter
Next, the remaining components of the boost converter, the inductance L40 as well as the two capacitors C40 and C41, should be soldered as shown in Figure 10. Note that the capacitors have a fixed polarity and must be soldered in the correct orientation, respecting the outline drawn on the PCB.

Figure 10. Assembly step 2: Soldering the boost converter inductance L40 and capacitors C40, C41, recommended testpoint TP3 for marked on the left
Check of the boost converter If everything is soldered correctly, the boost converter should be functional. This can be tested by connecting the board to power and measuring the voltage between testpoint TP3 (, 24 V) and GND, as indicated in Figure 10. Depending on the input voltage from the USB supply and the component tolerances, there might be some variations of the measured voltage. For the prototype, the open-circuit voltage of was measured as 23.948 V with an input voltage of 4.9295 V6.
Assembly of constant current sources, buzzer, and BNC connectors
Now, the remaining components can be soldered. It is recommended to start with the last surface mount devices, the constant current sources U50–U57, as shown on the left of Figure 11. Then, the through-hole components can be assembled, starting with the buzzer LS1 and then the potentiometers VR1–VR8 as well as the pin headers JP1–JP8, see right of Figure 11.

Figure 11. Assembly step 3: Soldering the constant current source ICs U50-U57 (left) as well as the buzzer LS1 (right), potentiometers VR1-VR8 and pinheaders JP1-JP8
Lastly, the BNC connectors X1-X4 should be soldered as depicted in Figure 12. After this, the board is fully assembled. Before it can be used, the constant current sources must be calibrated as described next.

Figure 12. Assembly step 4: Soldering the BNC connectors X1-X4
Current calibration
To calibrate the constant current sources, an ammeter, e.g., found in a multimeter, and suitable test leads, e.g., pincer test leads as shown in Figure 13, is required. Further, a load needs to be connected to the BNC headers, otherwise the output of the constant current source is open-circuit. For this, either an IEPE sensor can be connected, or, due to the current limitation through the IC, the constant current source output can simply be shorted to ground. One way to do this, is using a BNC to banana plug adapter and shorting the banana plugs using a wire, see Figure 13. The latter approach is recommended to avoid potential damage to an expensive sensor, e.g., due to assembly errors. Then, the recommended approach is as follows:

Figure 13. Recommended setup for calibrating the constant current sources of each channel
Connect the ammeter test leads to the pin header of the channel to be calibrated (polarity as in Figure 13)
Short the BNC connector, for example, using a shorted BNC to banana plug adapter
Adjust the current source using the corresponding potentiometer until the ammeter shows a current of 4 mA; the turning direction for increasing/decreasing the current is shown on the right of Figure 13
Remove the shorted BNC adapter and the test leads, then place a jumper on the pin header
Setting a current of 4 mA per channel is recommended for broad compatibility with IEPE devices [7]. Further, the boost converter was designed for this current draw (). As measurements of for different current levels show, see Table 4, the IEPE supply can provide 32 mA continuously without significant voltage drops, while at 40 mA (5 mA per channel), the voltage drops.
| Current drawn | 0 mA | 10 mA | 20 mA | 30 mA | 32 mA | 40 mA |
| Measured | 23.948 V | 23.928 V | 23.919 V | 23.918 V | 23.918 V | 22.604 V |
Table 4. Measured IEPE supply voltage for various current draws after a settling time of approximately one hour with input voltage V; measured using a Brymen BM786 Multimeter EEVBlog Edition in DC voltage mode; rated accuracy for utilized 60 V range with 60,000 counts is
Preparing the micro SD card and setting the device information
First, a micro SD card should be formatted for use with the OASIS-UROS board using a computer. The file system has to be FAT32, and, based on the utilized CACHE_SIZE and some testing, a block size of 32 kB is recommended for the best performance. After formatting, insert the SD card into the board.
Now, the system should successfully start-up and complete all required self checks, indicated by the message [OASIS] Finished booting.. At this point, the device information should also be set by invoking OASIS.SetDeviceInfo(). This allows to set all device information stored in the EEPROM, see appendix A for details, at once or individually. Important to correctly set is ADC_BIT, required for correct conversion to voltages, and OASIS_VER, which determines how the OASIS-GUI interacts with the device.
After this, the board is fully assembled, configured, and ready for operation.
Operation instructions
In this section, the recommended operation using the OASIS-GUI is described. The installation from the Python Package Index7 is described below, followed by the standard procedure to connect to the board, start a data acquisition, and retrieve a .mat file containing the measurement data.
Installing the OASIS-GUI
For this, a Python installation8 is required. To install the OASIS-GUI, a command prompt/terminal with the Python installation registered in the PATH is needed. Then, the OASIS-GUI can be installed using the Package Installer for Python (pip):
Command Prompt/Terminal with Python in PATH
> pip install OASIS-GUI
All required dependencies should be installed. The software was developed and tested under Windows, however, due to the platform independence of Python and some compatibility testing, it is also possible to use the OASIS-GUI under macOS and Linux.
Connecting to the board
To connect to an OASIS board, it is sufficient to connect it to the PC using a USB-C cable and open the OASIS-GUI from a command prompt/terminal with Python in the PATH using:
Command Prompt/Terminal with Python in PATH
> oasis-gui
This opens the user interface, see Figure 14, and searches for connected devices. By attempting to open communication with every connected Serial device and sending a request for device information (OASIS.RawInfo()), the connected boards and their COM port can be determined. All OASIS boards are placed into the drop-down menu at the top in the Device Selection and Search segment. The segments are explained in the following.

Figure 14. OASIS-GUI after opening with an OASIS-UROS board connected
Device Selection and Search Besides selecting the active device, i.e., the one used for data acquisition, this section allows to re-scan the connected devices using the Search Devices button.
Device Information Here, the information stored in the device EEPROM (see appendix § 12) is listed.
Acquisition Parameters These parameters are used for the next sample and are populated with default values. The OASIS-GUI sets the voltage ranges and the oversampling factor before the sample begins. If the sample should start with a trigger, this can also be enabled here, at the bottom of the window.
Device and GUI Log Logs from the connected OASIS devices and the OASIS-GUI are displayed here. The latter contains, for example, information about found Serial devices and if the communication was successful.
Post-processing Options Here, the behavior after a completed sample can be configured. It can be selected whether the acquired data should be plotted or saved after the sample. Using the dedicated buttons next to the options, both options can be manually invoked later.
Sample Control The data acquisition can be started using the Start Data Acquisition button. In case of transmission errors, the previous sample can be resend using Resend Previous Data.
Sampling data
Before starting the sampling process, the data acquisition parameters should be set. In the interest of flexibility, and to allow some experimentation, the sample parameters are as unlimited as possible. This means that there are some combinations of sample rate and oversampling factor that will not work. Generally, either a high sample rate (up to 36 kHz) or a high oversampling factor is possible. In the following, the individual parameters and their limitations are quickly discussed.
Sample Time (s) Defines for how long samples are acquired in seconds. It is also possible to enter decimal values, e.g., 2.56. There is no limitation for the sample time, except the storage space of the SD card.
Sampling Frequency (Hz) Determines how many samples are taken per second and must be a whole number. Due to limitations of the ESP32-S3 PWM hardware, not all values are possible, especially low sampling frequencies like 10 Hz. When this is the case, there will be an error message in the device log, and the sample process is aborted. As an upper limit, a sampling frequency of 36 kHz (with x16 oversampling) was found. If the sampling frequency is too high, i.e., the processing cannot be completed in time, the OASIS firmware will detect this and cancel the data acquisition with an error message. This message also denotes whether retrieving the samples from the ADC or writing the cache pages to the SD card took too long.
Oversampling Factor To reduce noise, the ADC can take multiple samples in quick succession that are averaged and this average is provided as the sample. How many samples are averaged is determined by the oversampling factor, e.g., a oversampling factor of x4 means that 4 samples are averaged [4]. Only certain values, listed in Table 5, can be chosen from the drop-down menu.
| Oversampling factor | x1 (Off) | x2 | x4 | x8 | x16 | x32 | x64 | x128 | x256 |
| Theoretical maximum throughput (kSPS) | 1000 | 500 | 250 | 125 | 62.5 | 31.25 | 15.6 | 7.8 | 3.9 |
Table 5. Oversampling factors and maximum theoretical throughput in kilo samples per second (kSPS) [4]
In Table 5, the theoretical maximum throughput is given with respect to the ADC’s capabilities. Due to other processing times, the achievable throughput, and with that, the maximum oversampling factor, is lower. Setting an oversampling factor that is too high can lead to unexpected results.
Voltage Ranges Here, the bipolar voltage range (positive and negative values) can be set for each channel individually using the drop-down menus. The Set for all Channels (V) option allows to set all eight channels to a specific range at once, channels can then still be changed individually. Table 6 lists all available voltage ranges and the corresponding voltage resolution achievable.
| Voltage range | ±2.5 V | ±5 V | ±6.25 V | ±10 V | ±12.5 V |
| Voltage resolution | 19 μV | 38.1 μV | 47.7 μV | 76.3 μV | 95.36 μV |
Table 6. Available voltage ranges and corresponding resolution [4]
Level Trigger This section allows to configure a voltage trigger on the first channel. When Enable Level Trigger is checked, the trigger level can be entered as a decimal voltage. The pre-trigger length cannot be set by the user and is predefined in the OASIS firmware through PRECACHE_SIZE, which is set to 1000 samples.
When all parameters are chosen as desired, the sample process can be started using the Start Data Acquisition button. During the data acquisition, the current status can be followed through the OASIS Device Log. The status bar at the bottom denotes the progress of transmitting the samples to the computer. For OASIS-UROS, this bar does not progress until after the sample has been completed and post-processed.
After successful data acquisition, the OASIS-GUI looks as displayed in Figure 15. Note that the device log also displays the name of the sample, here OASIS-UROS Alpha–2024-08-30–16.52.29, containing the device name as well as the date and time of the sample (based on the computer’s clock).

Figure 15. OASIS-GUI after data acquisition completed successfully
If not already selected as a post-processing option, the user can now manually invoke a plot of the sample with Show Previous Data. This will create a matplotlib plot of all eight channels over time, as depicted in Figure 16. If the sample was started with a trigger, the plot will look like shown in Figure 17. The difference is that the time axis does not start at zero, but at a negative value, denoting the pre-trigger data. Located at is the first sample that exceeded the set trigger level, which is visualized with a vertical dotted line as depicted in Figure 17.

Figure 16. Plot displayed by OASIS-GUI after the data acquisition is completed

Figure 17. Plot displayed by OASIS-GUI after the triggered data acquisition is completed
Sometimes, there can be errors in the transmission from the OASIS board to the computer. This manifests in obvious jumps in all channels at the same time. However, this can be remedied by requesting the sampled data again using the Resend Previous Data button.
Additionally, the user can save this data in a .mat file with the name of the sample using the Save Previous Data button. The .mat file will contain two variables:
OASISChannel( number of samples): Converted voltage sample points for each channelOASISTime( number of samples): Corresponding time axis
Validation and characterization
The performance and overall usability of the developed system are tested in the context of an experimental modal analysis. For this, a test case is set up and measurements are performed with the OASIS-UROS system as well as a commercial system, the Siemens LMS Scadas system. From the measured time data, frequency response functions (FRFs) and modal parameters (eigenfrequencies, damping ratios, and mode shapes) are estimated and compared using open source Python packages (pyFRF [8] and pyFBS [2]) for the OASIS measurements and the proprietary software Simcenter Testlab 2406 for the LMS measurements.
Experimental test setup
As a test case, a stiff aluminum beam structure is used, as depicted in Figure 18. Using screws, the structure is fixed to a vibration-isolated table. The system is excited with an automatic impact hammer provided by Maierhofer-Technology9. Seven acceleration responses are measured using triaxial acceleration sensors (PCB Piezotronics Model 356A03) glued to the structure. Only the vibrations perpendicular to the surface (-direction in the sensor coordinate system, as visualized in Figure 18) are measured.

Figure 18. Experimental setup of stiff aluminum beam structure fixed to a vibration-isolated table. The system is excited using an automatic impact hammer; acceleration responses perpendicular to the surface are measured using triaxial accelerometers, once with a commercial system and once using OASIS-UROS
Five impacts are performed using the same experimental setup, once with the sensors connected to the LMS system and once connected to the OASIS system. While this way, the signals will not be identical between the systems, it allows to validate the full electronic circuitry of OASIS-UROS, i.e., including the IEPE supply.
For both systems, the measurements were started using a trigger on the impact force and a set measurement duration of 2.56 s. While for the LMS system, the pre-trigger is included in this time, for OASIS, the pre-trigger is acquired additionally, resulting in 40 ms of additional time data. A sample rate of 25.6 kHz was used for OASIS and 51.2 kHz for LMS. The following analysis is limited to a maximum frequency of 12 kHz.
The raw time data of both systems, as well as the FRFs calculated using Simcenter Testlab, are available for download at [9]. Additionally, the Python script used to calculate FRFs and fit modal parameters is provided.
Frequency response function measurements
Since individual impacts are performed for each system, and due to some variations while changing the acquisition system, there are also differences in the excitation characteristics. To compare the impacts, Figure 19 shows all performed impacts’ time signal and excitation bandwidth.

Figure 19. Excitation signal of the automatic impulse hammer for each impact over time (left) and frequency (right). Impact belongs to data set of: — Siemens LMS Scadas System, — OASIS-UROS System
As can be seen, there is a drop in force magnitude between the individual runs. Compared to the impacts measured by the LMS system, the impacts performed for the OASIS measurements are overall lower in magnitude. Further, the excitation bandwidth is slightly lower for OASIS, which also manifests in a significant dip around 6 kHz for some of the measurements.
Before the FRF calculations, a force window (equal to one near the impact, zero elsewhere) is applied to the excitation time series of both systems. No response window was required for the LMS system, while the OASIS system profited from applying an exponential window, resulting in cleaner FRFs. Because the energy loss due to the window is not corrected, the magnitudes of the OASIS FRFs are lower.
The FRFs were estimated with the -estimator, using Simcenter Testlab for LMS and pyFRF [8] for OASIS. To compare the results, the FRF magnitude, phase, and coherence for each sensor are plotted in the following, for sensors 1 through 4 in Figure 20 and sensors 5 through 7 in Figure 21. The results of the LMS system are shown in blue, the ones of the OASIS system in orange.

Figure 20. Comparison of FRF magnitude, phase, and coherence for sensors 1-4 between commercial and open source system, — Siemens LMS Scadas System, — OASIS-UROS System

Figure 21. Comparison of FRF magnitude, phase, and coherence for sensors 5-7 between commercial and open source system, — *Siemens LMS Scadas System, — OASIS-UROS System
Considering the excitation bandwidth depicted in Figure 19, good results can be expected for both systems at least up to 4 kHz. Looking at the coherence, both systems’ FRFs show basically unity coherence up to around 3 kHz, besides the expected drops around the anti-resonances. The magnitude and phase in this region are also very similar between the systems, besides the reduced amplitudes of OASIS due to the response window and an increased amount of visible noise.
Starting from 3 kHz, a slight rise of the phase and a decrease of the coherence, not visible for the LMS system, can be seen; for instance, this is clearly visible for sensor 1 and 4 in Figure 20. At some points at the higher frequencies, e.g., between 8 and 10 kHz for sensor 2 (Figure 20), the same phase increase can be seen. Whether this can be traced back to inaccuracies of the sampling frequency of OASIS-UROS is currently unknown.
For all OASIS FRFs, a stark drop of coherence can be seen around 6 kHz. This could be correlated to the drop in the excitation spectrum, as shown in Figure 19, which is not present in the LMS impacts. The exact reason cannot be identified here because there are too many variables involved, i.e., different impacts are used, the acquisition hardware as well as the software are different, and not all used parameters match.
In general, there are significant differences in the FRFs’ magnitude and phase above around 4 kHz, depending on the viewed sensor. Whether this has negative effects depends on the further analysis for which the FRFs are used. For example, in the context of frequency-based substructuring, small errors can already be detrimental due to the required inversion of the FRF matrix [10]. Whether OASIS-UROS is suitable for this application must be evaluated separately. For other analyses less sensitive to such errors, like experimental modal analysis, the observed differences in the FRFs might be less relevant. Therefore, the results of an experimental modal analysis are compared in the next section.
Experimental modal analysis results
For the LMS system, the modal identification built into Simcenter Testlab using the PolyMAX [11] algorithm is used. For OASIS, the implementation found in pyFBS [2] is used. Here, a combination of the poly-reference Least-Squares Complex Frequency (pLSCF) and Least-Squares Frequency Domain (LSFD) methods as described in [12] is used. All modes, observable with the test setup, until 8 kHz are identified. For this, two modal fits are performed, once from 1 to 4000 Hz and once from 4 to 8.3 kHz.
The extracted eigenfrequencies and damping ratios are summarized in Table 7. Additionally, the difference between the OASIS results and the LMS results is given. For the eigenfrequencies, the relative difference in percent is given, while for the damping ratios, the absolute difference of the damping ratio is given. Note, that this does not compare the two modal fit algorithms, but the entire acquisition and post-processing stack.
| Eigenfrequencies | Damping ratios | |||||
| Mode | LMS | OASIS | Relative Difference | LMS | OASIS | Absolute Difference |
| Mode 1 | 74.8 Hz | 74.8 Hz | 0.00 % | 0.16 % | 0.13 % | +0.03 % |
| Mode 2 | 209.1 Hz | 209.2 Hz | 0.00 % | 0.14 % | 0.14 % | 0.00 % |
| Mode 3 | 914.5 Hz | 913.4 Hz | -0.12 % | 0.44 % | 0.42 % | -0.02 % |
| Mode 4 | 1594.0 Hz | 1593.4 Hz | -0.04 % | 0.31 % | 0.73 % | +0.42 % |
| Mode 5 | 2662.3 Hz | 2669.5 Hz | +0.27 % | 0.52 % | 0.46 % | -0.06 % |
| Mode 6 | 2692.5 Hz | 2687.1 Hz | -0.20 % | 0.51 % | 0.43 % | -0.08 % |
| Mode 7 | 4189.7 Hz | 4198.4 Hz | +0.20 % | 1.03 % | 0.72 % | -0.31 % |
| Mode 8 | 5576.8 Hz | 5578.9 Hz | +0.04 % | 0.55 % | 1.06 % | +0.51 % |
| Mode 9 | 7076.7 Hz | 7075.3 Hz | -0.02 % | 0.36 % | 0.39 % | +0.03 % |
| Mode 10 | 7930.8 Hz | 7931.8 Hz | +0.01 % | 0.24 % | 0.27 % | +0.03 % |
Table 7. Summary of experimental modal analysis comparison of commercial system (Siemens LMS Scadas System and PolyMAX [11]) with open source system (OASIS-UROS and pyFBS modal identification [12])
For the eigenfrequencies, the most significant deviations can be seen for modes 5 to 7, where the highest deviation occurs for mode 5 with +0.27 % or +7.2 Hz. The higher modes, i.e., modes 8 through 10, show less discrepancy, both, in relative and absolute values. This indicates that there is no significant shift with increasing frequency, as could result from an inaccurate sampling clock of the OASIS system.
For the damping ratios, greater differences can be observed, especially for modes 4, 7, and 8. As previously mentioned, the exact reason for this cannot be pinpointed here due to the entirely different acquisition and post-processing setups. A separate analysis, where, for example, only the acquisition hardware differs, would have to be performed. However, the comparison performed here evaluates the real-world use case, where only free software would be used in conjunction with OASIS.
Lastly, the estimated mode shapes are compared by building the Cross-Modal Assurance Criterion (Cross-MAC) between the two mode sets. The resulting MAC matrix is visualized in Figure 22. As can be seen from the close to unity values on the diagonal, both mode shape sets match pretty closely. Only mode 7 shows a lower MAC value, which might be resolvable by selecting another pole from the stabilization diagram.

Figure 22. Cross-Modal Assurance Criterion between the mode shapes identified by the commercial system (Siemens LMS Scadas System) and the open source system (OASIS-UROS)
To summarize, for frequencies up to 3 kHz, no significant differences were observable in the FRFs estimated by the commercial system with proprietary software and those retrieved using open source software and hardware. Besides greater differences in the damping ratios, the results of an experimental modal analysis matched also pretty closely between commercial and open source system. While OASIS-UROS cannot match the performance of the commercial system, the authors believe that, especially when comparing the costs, the developed system is a viable alternative for students, people in academia, or smaller companies that have a constrained budget or require complete insight as well as adaptability of the hardware and software.
CRediT author statement
O. M. Zobel: Conceptualization; Methodology; Software; Validation; Formal Analysis; Investigation; Data Curation; Writing - Original Draft; Writing - Review & Editing; Visualization; J. Maierhofer: Conceptualization; Methodology; Validation; Formal Analysis; Investigation; Writing - Original Draft; Writing - Review & Editing. A. Köstler: Validation; Investigation; Resources; Writing - Review & Editing. D. J. Rixen: Resources, Writing - review & editing, Supervision.
Acknowledgements
This research did not receive any specific grant from funding agencies in the public, commercial, or not-for-profit sectors.
Command reference
Note: Included here is the command reference at the point of publication, the current version can be found at: https://gitlab.com/oasis-acquisition/oasis-commandreference
OASIS Command Reference 2.0
This document summarizes the commands of the OASIS command line interface. While the system can be used in manual mode, it is recommended to use the OASIS-GUI that automates the device interaction.
Communication
Communication is possible over a serial interface with a baud rate of 1.000.000.
The symbols Original, UROS and LITE denote that the feature/command pattern is valid for the respective OASIS architecture. Features/Commands valid for all architectures are not marked.
Wireless Sample Synchronization (WSS)
WSS can be enabled via the OASIS-GUI. One device acts as the WSS Source, which initiates the sampling of all WSS Sinks. The WSS mode is set with the OASIS.Sample command.
Status LED
| LED color | OASIS status |
| Green | Normal operation. Ready for commands, no previous error. |
| Blue | System is actively sampling data. |
| Blue blinking | System is post-processing the previous sample. |
| Yellow blinking | The system is sending the previous sample to the connected PC. |
| Cyan | System is sampling with WSS enabled and is the WSS Source. |
| Purple | System is in WSS Sink mode and either waiting for the WSS Source or already sampling. |
| Red | 2 beeps: The command previously sent is invalid. 3 beeps: Sampling did not finish in time |
Table 1 (PDF p. 34). States described by the status LED
Sampling
Note: All sample commands use the set voltage range and, if applicable, oversampling factor. Refer to the Configuration section for more details about how the former can be changed.
OASIS.Sample (Time in s, Sampling Frequency in Hz, Trigger level in V, WSS Sync mode, Filename)
Samples for a duration of Time in s with the sample rate Sampling Frequency in Hz.
When a Trigger level in V of zero is passed, the sample acquisition starts immediately. Otherwise, the sampling starts when the voltage on channel 1 exceeds Trigger level in V. This includes pre-trigger data sent over the serial interface after the main sampling has finished. The pre-trigger data has to be requested by sending the command Drq() over the serial interface.
The WSS Sync mode has also to be specified, where 0 = Off, 1 = Source, 2 = Sink.
Lastly, the Filename is used for the files saved to the SD card and must be unique. When a Filename is provided for which a sample file already exists, the user is asked whether this file should be overwritten.
Send data stored on the SD card UROS LITE
OASIS.SendData (Filename)
Sends the raw bytes belonging to Filename if such files exist on the SD card.
Configuration
Set voltage range
Original LITE OASIS.SetVoltageRange (ID CH1, ID CH2, ID CH3, ID CH4)
Sets the voltage range for all channels to either V (ID 2) or V (ID 4). Setting different IDs for channels will result in an error and is not possible due to hardware limitations of the ADC.
UROS OASIS.SetVoltageRange (ID CH1, ID CH2, ID CH3, ID CH4, ID CH5, ID CH6, ID CH7, ID CH8)
Sets the voltage range on a per-channel basis. Available voltage ranges:
| Voltage range ID | Voltage range |
| 1 | V |
| 2 | V |
| 3 | V |
| 4 | V |
| 5* | V |
Table 2 (PDF p. 35). Available voltage ranges for OASIS-UROS
Get voltage range UROS
OASIS.GetVoltageRange ()
Reads the currently configured voltage ranges from the ADC registers and displays a formatted message.
Set oversampling factor UROS
OASIS.SetOversampling (Oversampling factor ID)
Sets the voltage range on a per-channel basis. Available voltage ranges:
| Oversampling factor ID | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| Oversampling factor | x1 (Off) | x2 | x4 | x8 | x16 | x32 | x64 | x128 | x256 |
Table 3 (PDF p. 35). Available oversampling factors for OASIS-UROS
Set device information
OASIS.SetDeviceInfo ()
Allows configuration of device information saved in the EEPROM. The user is presented with a menu that allows to change all or only specific device details. Refer to table 4 for detailed EEPROM information.
Display device information
OASIS.Info()
Displays information about the device saved in the EEPROM formatted for human reading. Refer to Table 4 for detailed EEPROM information.
Return raw device information
OASIS.RawInfo()
Returns information about the device saved in the EEPROM without formatting intended for automatic device identification, e.g., used by the OASIS GUI. Refer to Table 4 for detailed EEPROM information.
Mute the buzzer
OASIS.Mute()
Completely mutes the integrated buzzer. The setting persists after reset/power off.
Unmute the buzzer
OASIS.Unmute()
Unmutes the integrated buzzer. The setting persists after reset/power off.
Enable WiFi access point Original LITE
OASIS.EnableWiFi()
Enables the WiFi Access Point. Necessary for WiFi communication. The setting persists after reset/power off.
Disable WiFi access point Original LITE
OASIS.DisableWiFi()
Disables the WiFi Access Point. This is necessary for sampling over the serial interface with the original OASIS. The firmware will automatically enforce disabling the WiFi when data sampling over the Serial interface is requested, and the WiFi Access Point is turned on. The setting persists after reset/power off.
References
- [1]Zobel, O. M., Maierhofer, J., Köstler, A., and Rixen, D. J. OASIS-UROS V1.1 Project Files. Sept. 2024. DOI: 10.5281/zenodo.13763227.DOI
- [2]Bregar, T., El Mahmoudi, A., Kodrić, M., Ocepek, D., Trainotti, F., Pogačar, M., and Göldeli, M. pyFBS (v0.3.1). 2023. URL: https://pyfbs.readthedocs.io/en/latest/index.html.
- [3]Zobel, O. M., Maierhofer, J., and Rixen, D. J. “OASIS: Open Acquisition System for IEPE Sensors: For Academic Research and Teaching Purposes”. In: Conference Proceedings of the Society for Experimental Mechanics Series, 2024, pp. 79–86. DOI: 10.1007/978-3-031-34938-6_9.DOI
- [4]Analog Devices. AD7606C-18 - 8-Channel DAS with 18-Bit, 1 MSPS Bipolar Input, Simultaneous Sampling ADC - Datasheet. URL: https://www.analog.com/media/en/technical-documentation/data-sheets/ad7606c-18.pdf.
- [5]Espressif Systems. ESP32-S3 - Technical Reference Manual. URL: https://www.espressif.com/sites/default/files/documentation/esp32-s3_technical_reference_manual_en.pdf.
- [6]USB Implementers Forum, Inc. Universal Serial Bus Specification - Revision 2.0. Apr. 2000. URL: https://www.usb.org/document-library/usb-20-specification.
- [7]Lally, J. Technical Note TN-17: ACCELEROMETER SELECTION CONSIDERATIONS - Charge and ICP® Integrated Circuit Piezoelectric. PCB Piezotronics, Inc. Depew, NY 14043. 2005. URL: https://www.pcb.com/techsupport/docs/vib/TN_17_VIB-0805.pdf.
- [8]Slavić, J., Česnik, M., Zaletelj, K., and Novak, L. pyFRF: Frequency response function as used in structural dynamics (v1.1.1). 2024. URL: https://github.com/ladisk/pyFRF.
- [9]Zobel, O. M., Maierhofer, J., Köstler, A., and Rixen, D. J. OASIS-UROS Experimental Validation Measurement Data. Dataset. 2024. DOI: 10.14459/2024mp1754305.DOI
- [10]Allen, M. S., Rixen, D., Seijs, M. van der, Tiso, P., Abrahamsson, T., and Mayes, R. L. Substructuring in Engineering Dynamics - Emerging Numerical and Experimental Techniques. 1st ed. Springer Cham, 2020. ISBN: 978-3-030-25532-9. DOI: 10.1007/978-3-030-25532-9.DOI
- [11]Peeters, B., Van der Auweraer, H., Guillaume, P., and Leuridan, J. “The PolyMAX Frequency-Domain Method: A New Standard for Modal Parameter Estimation?” In: Shock and Vibration 11 (Aug. 2004), pp. 395–409. DOI: 10.1155/2004/523692.DOI
- [12]Guillaume, P., Verboven, P., Vanlanduit, S., Van der Auweraer, H., and Peeters, B. “A poly-reference implementation of the least-squares complex frequency-domain estimator”. In: Proceedings of IMAC XXI (2003).


