Protocols

5.3.3 Calibration (MPE required)

All the calibration procedures, independently from the sensors to be calibrated, must be started using the set state command to enter the calibration state (HEX code: 0x07), providing the calibration type (i.e., which identify the sensor to be calibrated) as first argument and the field intensity value to fit (i.e., a 4-bytes floating point value) as second input parameter.

TRANSMISSION

RESPONSE

• CALIBRATION TYPE
  Define what MEMS is to be calibrated.
  • Accelerometer 0x00
  • Gyroscope 0x01
  • Magnetometer 0x02

• FIELD INTENSITY
  It is a 32-bit floating point representing the field to be fit by the calibration routine.
  • Accelerometer 1000 (HEX: 0x447a0000, that must be transmitted LSB)
  • Gyroscope 0
  • Magnetometer 400.0 (HEX: 0x43c80000, that must be transmitted LSB)

GYROSCOPE
The gyroscope calibration entails leaving the system still for the duration of the procedure. The aim is to estimate gyroscope offset around each axis. The calibration start is advertised by the flashing of green LED. The system must be left still during the data sampling.

ACCELEROMETER
The calibration procedure for the accelerometer entails sampling the data of a still system in 14 different positions. The calibration procedure starts with the first position. The system should be left still during the data sampling, signaled by fast flashing of the green LED. The sampling of the next position can be started by sending an ACK for the set state command, or the calibration procedure can be started with the data sampled so far by sending a NACK for the set state command.

TRANSMISSION

As stated above, by sending the provided ACK, the system will start a new sampling phase, so the user should make sure to position the system correctly before sending the ACK. The system should remain still for the entire duration of the sampling phase (green led flashing fast) and can be moved to allow for re-positioning while the green led is flashing slowly. Once the sampling phase is completed (i.e., 14 different positions is the suggested method) the user should send a NACK to start the calibration algorithm based on previously sampled data.

TRANSMISSION

MAGNETOMETER
The magnetometer calibration entails performing as many different system rotations as possible during the procedure.

5.4 Data Acquisition

Data acquisition is controlled by using the set state command performed on Command Characteristic. Based on the selected acquisition channel (i.e., STREAM or LOG, independently from the selected acquisition mode), the device starts to stream the data through notification on Data Characteristic or save the data on the flash memory, respectively. The general format of the command is as follows, independently from the sensor configuration, state, and selected acquisition mode or frequency.

To START data acquisition, the following command must be composed.

TRANSMISSION

RESPONSE

In this case, the response is a confirmation message including the full-scale configuration currently set as well as the selected acquisition mode and frequency.

• ACQUISITION MODE
  It is the 24-bit mask representing the acquisition mode currently set. It determines the set of data read from the device.
• ACQUISITION FREQUENCY
  It is the 8-bit enum representing the desired acquisition frequency currently set. The acquisition will be performed at this frequency.
• SENSORS FULL SCALE
  It is an 8-bit unsigned integer representation of the current full scales configuration that must be decoded performing a bitwise AND using the masks provided in Table 8.

TABLE 13: ACQUISITION MODES DEFINITION.

Example of packet dimension computation, given a specific acquisition mode combination:

public static int GetPacketDimension(DataMode inMode)
{
    int packet_dimension = 0;

    // Compute packet dimension given data acquisition mode
    if ((inMode & DataMode.DATA_MODE_GYRO) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_GYRO;
    if ((inMode & DataMode.DATA_MODE_AXL) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_AXL;
    if ((inMode & DataMode.DATA_MODE_HDR) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_HDR;
    if ((inMode & DataMode.DATA_MODE_MAGN) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_MAGN;
    if ((inMode & DataMode.DATA_MODE_ORIENTATION) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_ORIENTATION;
    if ((inMode & DataMode.DATA_MODE_TIMESTAMP) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_TIMESTAMP;
    if ((inMode & DataMode.DATA_MODE_TEMP_HUM) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_TEMP_HUM;
    if ((inMode & DataMode.DATA_MODE_TEMP_PRESS) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_TEMP_PRESS;
    if ((inMode & DataMode.DATA_MODE_RANGE) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_RANGE;
    if ((inMode & DataMode.DATA_MODE_SOUND) > 0)
        packet_dimension += (int)DataSize.DATA_SIZE_SOUND;

    // Check packet dimension consistency
    // It MUST be a dividend of 120 (2040)
    if (packet_dimension == 6 || packet_dimension == 12 || packet_dimension == 24 ||
            packet_dimension == 30 || packet_dimension == 60)
        return packet_dimension;

    // Return -1 in case of data dimension inconsistency
    return -1;
}

TABLE 14: ACQUISITION FREQUENCIES.

To STOP data acquisition, the following command must be composed to put the system in IDLE (0x02) state.

TRANSMISSION

RESPONSE

5.4.1  Acquisition Modes

Different combination of the above fields allows to perform data acquisition in a few different operating modes:

• STREAMING
  The device is connected to a master via BLE, typically desktop or mobile application, and performs a real-time streaming of the data based on the
  selected acquisition mode and frequency.
  • BUFFERED
    Data is arranged within the 128 bytes of the Data characteristic according to the packet dimension based on the selected acquisition mode.
    The notification frequency is lower than the acquisition frequency because the data is pooled within the Data characteristic.

TRANSMISSION

RESPONSE

Example of number of packets computation given a specific data acquisition mode combination:

public static int GetNumberOfPackets(DataMode mode)
{
    // Compute packet dimension and check its consistency given data acquisition mode
    int packet_dimension = GetPacketDimension(mode);

    // Compute overall number of packets contained into a data characteristic update
    if (packet_dimension != -1)
        return (120 / packet_dimension);

    // Return -1 in case of data dimension inconsistency
    return -1;
}

• • DIRECT
    Data is arranged within the 128 bytes of the Data characteristic one packet at a time. The notification and acquisition frequency match.

TRANSMISSION

RESPONSE

In this case it is not necessary to compute the overall number of packets: there is one packet for each notification.

• LOG
  The device can be connected to a master via BLE or can be controlled directly from the smart button, if properly configured. The data is acquired and saved into the device flash memory.
  • COMMAND
    The log acquisition can be controlled (i.e., start, stop) using the set state command.

TRANSMISSION

RESPONSE

• • BUTTON
    If properly configured (see Section 5.4.2 for further details), the acquisition can be started and stopped with a single click on the system button.

5.4.2 Button Log Configuration

The button log configuration command can be executed in both write and read mode. The HEX code is 0x50 (write), and 0xD0 (read).

To SET a new button log configuration, the following command must be composed.

TRANSMISSION

RESPONSE

To GET the current button log configuration, the following command must be composed.

TRANSMISSION

RESPONSE

• ACQUISITION MODE
  It is the 24-bit mask representing the acquisition mode to be set (write) or currently set (read) for log operations. It must be encoded in HEX format.
• ACQUISITION FREQUENCY
  It is the 8-bit enum representing the desired acquisition frequency to be set (write) or currently set (read) for log operations.

Example:

• ACQUISITION MODE: “27 00 00” which corresponds to 39 as 32-bit unsigned integer. The corresponding data acquisition mode combination can be extracted by performing a bitwise AND operation using the hex code of Table 13.
• ACQUISITION FREQUENCY: “08” which corresponds to 200 Hz. See Table 14.

5.5 Data Decoding

5.5.1 Gyroscope: 3D Angular Rate

The 3D angular rate is provided as a raw value read out from the sensor registers, represented as a two’s complement, Little Endian encoded, 16-bit signed integer value. The conversion from raw value to actual measurement must be performed on the master side considering the actual full-scale set and the corresponding sensitivity coefficient (see Table 8).

The output measure is provided in Degrees Per Second, dps.

Each channel (i.e., x, y, z) must be converted from raw 2-bytes array to the corresponding 16-bit signed integer representation (i.e., Int16) and then scaled to the actual metric representation multiplying it by the appropriate sensitivity coefficient.

Example of decoding implementation:

private static float[] DataTypeGYR(byte[] currentPayload, float gyr_res)
{
    // Define 3-elements array of float (i.e., x, y, z channels)
    float[] currentData = new float[3];

    // Define temporary internal variable used for data conversion
    byte[] tmp = new byte[2];

    // Iterate across Gyroscope channels
    for (int i = 0; i < 3; i++)
    {
        // Extract channel raw value (i.e., 2-bytes each)
        Array.Copy(currentPayload, 2*i, tmp, 0, 2);

        // Convert to Int16 and apply sensitivity scaling
        currentData[i] = (float)(BitConverter.ToInt16(tmp, 0) * gyr_res);
    }

    // Return decoded Gyroscope reading
    return currentData;
}

5.5.2 Accelerometer: 3D Linear Acceleration

The 3D acceleration is provided as a raw value read out from the sensor registers, represented as a two’s complement, Little Endian encoded, 16-bit signed integer value. The conversion from raw value to actual measurement must be performed on the master side considering the actual full-scale set and the corresponding sensitivity coefficient (see Table 8).

The output measure is provided in millig, mg.

Each channel (i.e., x, y, z) must be converted from raw 2-bytes array to the corresponding 16-bit signed integer representation (i.e., Int16) and then scaled to the actual metric representation multiplying it by the appropriate sensitivity coefficient.

Example of decoding implementation:

private static float[] DataTypeAXL(byte[] currentPayload, float axl_res)
{
    // Define 3-elements array of float (i.e., x, y, z channels)
    float[] currentData = new float[3];

    // Define temporary internal variable used for data conversion
    byte[] tmp = new byte[2];

    // Iterate across Accelerometer channels
    for (int i = 0; i < 3; i++)
    {
        // Extract channel raw value (i.e., 2-bytes each)
        Array.Copy(currentPayload, 2*i, tmp, 0, 2);

        // Convert to Int16 and apply sensitivity scaling
        currentData[i] = (float)(BitConverter.ToInt16(tmp, 0) * axl_res);
    }

    // Return decoded Accelerometer reading
    return currentData;
}

5.5.3 Magnetometer: 3D Magnetic Field Intensity

The 3D angular rate is provided as a raw value read out from the sensor registers, represented as a two’s complement, Little Endian encoded, 16-bit signed integer value. The conversion from raw value to actual measurement must be performed on the master side considering the actual full-scale set and the corresponding sensitivity coefficient (see Table 8).

The output measure is provided in milli-Gauss, mGauss.

Each channel (i.e., x, y, z) must be converted from raw 2-bytes array to the corresponding 16-bit signed integer representation (i.e., Int16) and then scaled to the actual metric representation multiplying it by the appropriate sensitivity coefficient. It is worth noting that the sensitivity of the magnetometer depends on the hardware revision of the user board. In the first hardware revision the sensitivity of the sensor is a fixed 1.5 mGauss/LSB.

Example of decoding implementation:

private static float[] DataTypeMAG(byte[] currentPayload, float mag_res)
{
    // Define 3-elements array of float (i.e., x, y, z channels)
    float[] currentData = new float[3];

    // Define temporary internal variable used for data conversion
    byte[] tmp = new byte[2];

    // Iterate across Magnetometer channels
    for (int i = 0; i < 3; i++)
    {
        // Extract channel raw value (i.e., 2-bytes each)
        Array.Copy(currentPayload, 2*i, tmp, 0, 2);

        // Convert to Int16 and apply sensitivity scaling
        currentData[i] = (float)(BitConverter.ToInt16(tmp, 0) * mag_res);
    }

    // Return decoded Magnetometer reading
    return currentData;
}

5.5.4 High Dynamic Range (HDR) Accelerometer: 3D Linear Acceleration

The 3D HDR acceleration is provided as a raw value read out from the sensor registers, represented as a two’s complement, left justified, Little Endian encoded, 12-bit signed integer value. The conversion from raw value to actual measurement must be performed on the master side considering the actual full-scale set and the corresponding sensitivity coefficient (see Table 8).

Each channel (i.e., x, y, z) must be converted from raw 2-bytes array to the corresponding 16-bit signed integer representation (i.e., Int16) and then scaled to the actual metric representation multiplying it by the appropriate sensitivity coefficient. It is worth noting that the sensitivity provided in Table 8 does not account for the 4 bits right shift operation which shall be carried out to account for the 12-bit resolution of the sensor. This means that the integer value must be divided by 16 before sensitivity scaling.

Example of decoding implementation:

private static float[] DataTypeHDR(byte[] currentPayload, float hdr_res)
{
    // Define 3-elements array of float (i.e., x, y, z channels)
    float[] currentData = new float[3];

    // Define temporary internal variable used for data conversion
    byte[] tmp = new byte[2];

    // Iterate across HDR channels
    for (int i = 0; i < 3; i++)
    {
        // Extract channel raw value (i.e., 2-bytes each)
        Array.Copy(currentPayload, 2*i, tmp, 0, 2);

        // Convert to Int16 and apply resolution and sensitivity scaling
        currentData[i] = (float)((BitConverter.ToInt16(tmp, 0) / 16) * hdr_res);
    }

    // Return decoded HDR reading
    return currentData;
}

5.5.5 Orientation Quaternion (MPE required)

The orientation is presented as a normalized quaternion, but only the three imaginary components are reported in the data, 2 bytes each. Each reported component is transmitted as a signed integer, mapped inside the range [-1,1], meaning that the LSB value is

From this, the user should read the 2 bytes corresponding to the quaternion component as a signed 16-bit integer, then divide it by 32767 to obtain the float equivalent (with the approximations intrinsic to the method). The user can then use the knowledge that the quaternion is normalized, and recalculate the real component as

Since this method drops the real part of the quaternion, given a quaternion q:

Imaginary components of quaternion q are transmitted as −𝑞1, −𝑞2 and −𝑞3, so that the reconstructed quaternion is

Example of decoding implementation:

private static float[] DataTypeOrientation(byte[] currentPayload)
{
    // Define 4-elements array of float (i.e., qw, qi, qj, qk channels)
    float[] currentData = new float[4];

    // Define temporary internal variable used for data conversion
    byte[] tmp = new byte[2];

    // Orientation Quaternion (i.e., UNIT QUATERNION)
    float[] tempFloat = new float[3];
    for (int i = 0; i < 3; i++)
    {
        // Extract channel raw value (i.e., 2-bytes each) and convert to Int16
        tempFloat[i] = BitConverter.ToInt16(currentPayload, 2*i);

        // Keep into account the data resolution
        tempFloat[i] /= 32767;
                
        // Assign imaginary parts of quaternion
        currentData[i + 1] = tempFloat[i];
    }

    // Compute real component of quaternion given immaginary parts
    currentData[0] = (float)Math.Sqrt(1 - (currentData[1] * currentData[1] +
            currentData[2] * currentData[2] + currentData[3] * currentData[3]));

    // Return decoded Unit Quaternion
    return currentData;
}

5.5.6 Timestamp

The sub-second timestamp reports the number of milliseconds since 26 January 2020 00:53:20. The user can reconstruct the Unix-style epoch by adding the epoch of the date (in milliseconds), 1580000000.

Example of decoding implementation:

private static ulong DataTypeTimestamp(byte[] currentPayload)
{
    // Set current data variable to 0
    ulong currentData = 0;

    // Get raw byte array representation to be decoded
    byte[] tmp = new byte[8];
    Array.Copy(currentPayload, 0, tmp, 0, 6);
            
    // Convert raw data to 64-unsigned integer representation
    UInt64 tempTime = (ulong)BitConverter.ToUInt64(tmp, 0);
    tempTime &= 0x0000FFFFFFFFFFFF;

    // Add reference epoch
    tempTime += ((UInt64)REFERENCE_EPOCH) * 1000;

    currentData = tempTime;

    // Return current date/time
    return currentData;
}

5.5.7 Temperature and Relative Humidity

The temperature and relative humidity are sampled at a fixed rate of 25 Hz. The user can reconstruct the values by converting the provided byte array into an unsigned integer and using the following equations:

𝑇=𝐷𝑎𝑡𝑎_𝑎𝑟𝑟𝑎𝑦_𝑇 ⋅ 0.002670−45

𝑅𝐻=𝐷𝑎𝑡𝑎_𝑎𝑟𝑟𝑎𝑦_𝑅𝐻 ⋅ 0.001907−6

The user should also note that, to keep the data size to the constant 6-bytes value, 2 padding zeros are added after the relative humidity data

5.5.8 Temperature and Ambient Barometric Pressure

The temperature and ambient pressure are sampled at a fixed rate of 25 Hz. The user can reconstruct the values by converting the provided byte array into an unsigned integer and using the following equations:

The user should also note that, to keep the data size to the constant 6-bytes value, one padding zero is added after the temperature data.

5.5.9 Range and Light Intensity

The range, visible light intensity and infrared light intensity are sampled at a fixed rate of 25 Hz.

The user can reconstruct the true ambient light intensity in lumens via a spline fit, as follows:

• The user should identify the reported value of the visible light and infrared light by converting the reported values to 16-bit unsigned integers. For the sake of this chapter, the two converted values will be referred as 𝐿𝑈𝑀_𝑉𝐼𝑆 and 𝐿𝑈𝑀_𝐼𝑅.
• The user should then identify the overall light source type using the ratio between 𝐿𝑈𝑀_𝑉𝐼𝑆 and 𝐿𝑈𝑀_𝐼𝑅:
  • CASE 1: 𝐿𝑈𝑀_𝐼𝑅/𝐿𝑈𝑀_𝑉𝐼𝑆  <0.109 covers LEDs, fluorescence, and sunlight
  • CASE 2: 𝐿𝑈𝑀_𝐼𝑅/𝐿𝑈𝑀_𝑉𝐼𝑆  <0.429 covers incandescent and halogen lamps
  • CASE 3: 𝐿𝑈𝑀_𝐼𝑅/𝐿𝑈𝑀_𝑉𝐼𝑆  <(0.95 ⋅ 1.45) covers dimmed incandescent and halogen lamps
  • CASE 4: 𝐿𝑈𝑀_𝐼𝑅/𝐿𝑈𝑀_𝑉𝐼𝑆  <(1.5 ⋅ 1.45) covers dimmed incandescent and halogen lamps
  • CASE 5: 𝐿𝑈𝑀_𝐼𝑅/𝐿𝑈𝑀_𝑉𝐼𝑆  <(2.5 ⋅ 1.45)
  • CASE 6: all other cases
• Once identified the case, the true lumens value can be calculated with the following equations:
  • CASE 1: 𝐿𝑈𝑋 = 1.534 ⋅ 𝐿𝑈𝑀_𝑉𝐼𝑆 − 3.759 ⋅ 𝐿𝑈𝑀_𝐼𝑅
  • CASE 1: 𝐿𝑈𝑋 = 1.534 ⋅ 𝐿𝑈𝑀_𝑉𝐼𝑆 − 3.759 ⋅ 𝐿𝑈𝑀_𝐼𝑅
  • CASE 2: 𝐿𝑈𝑋 = 1.339 ⋅ 𝐿𝑈𝑀_𝑉𝐼𝑆 − 1.972 ⋅ 𝐿𝑈𝑀_𝐼𝑅
  • CASE 3: 𝐿𝑈𝑋 = 0.701 ⋅ 𝐿𝑈𝑀_𝑉𝐼𝑆 − 0.483 ⋅ 𝐿𝑈𝑀_𝐼𝑅
  • CASE 4: 𝐿𝑈𝑋 = 2 ⋅ 0.701 ⋅ 𝐿𝑈𝑀_𝑉𝐼𝑆 − 1.18 ⋅ 0.483 ⋅ 𝐿𝑈𝑀_𝐼𝑅
  • CASE 5: 𝐿𝑈𝑋 = 4 ⋅ 0.701 ⋅ 𝐿𝑈𝑀_𝑉𝐼𝑆 − 1.33 ⋅ 0.483 ⋅ 𝐿𝑈𝑀_𝐼𝑅
  • CASE 6: 𝐿𝑈𝑋 = 8 ⋅ 0.701 ⋅ 𝐿𝑈𝑀_𝑉𝐼𝑆

In summary, the user should implement the following logic:

if (ir / vis < 0.109f) {
    lux = 1.534f * vis - 3.759f * ir;
} else if (ir / vis < 0.429f) {
    lux = 1.339f * vis - 1.972f * ir;
} else if (ir / vis < 0.95f * 1.45f) {
    lux = 0.701f * vis - 0.483f * ir;
} else if (ir / vis < 1.5f * 1.45f) {
    lux = 2.0f * 0.701f * vis - 1.18f * 0.483f * ir;
} else if (ir / vis < 2.5f * 1.45f) {
    lux = 4.0f * 0.701f * vis - 1.33f * 0.483f * ir;
} else {
    lux = 8.0f * 0.701f * vis;
}

5.6 Memory

5.6.1 Control

The memory control command can be executed in both write and read mode. The HEX code is 0x20 (write), and 0xA0 (read).

To perform an ERASE MEMORY operation, the command must be executed in WRITE mode. The following command must be composed.

TRANSMISSION

RESPONSE

• MEMORY ERASE STATUS
  It provides feedback on memory erase process status. It can be one of the following values:
  • 0x01, erase memory correctly scheduled.
  • 0x02, erase memory completed.

The user should expect two ACKs, the first containing the MEMORY ERASE STATUS code 0x01, once the procedure has started, and a second one containing code 0x02 once the procedure has been completed. The entire memory erase should take around 3 seconds to complete.

To GET the current memory status in terms of available space (i.e., in percentage format) and number of files currently saved in memory, the following command must be composed.

TRANSMISSION

RESPONSE

• AVAILABLE SPACE
  Available space, provided in percentage format (i.e., 8-bit unsigned integer value).
• NUMBER OF FILES
  It is the 16-bit unsigned integer representing the number of files saved in memory.

5.6.2 File Information

The file information command can be executed in read-only mode. The HEX code is 0xA1.

To GET the file info about a specific file identifier, the following command must be composed.

TRANSMISSION

RESPONSE

• FILE ID
  The files are retrieved passing an index (i.e., between 0 and N-1, where N is the number of files currently stored in the system) as the command argument. If the requested file is present, the command will respond with the following information, in order:
  • TIMESTAMP
    Start timestamp of the file (i.e., 5 bytes).
    It must be decoded by converting the raw values into a 64-bit unsigned integer, and adding the REFERENCE_EPOCH = 1580000000², multiplied by 1000 to keep into account the milliseconds resolution.
  • SENSORS FULL SCALES
    The sensors full scale code (i.e., 1 byte). It must be decoded performing a bitwise AND using the bit mask defined in Table 9.
  • DATA ACQUISITION MODE
    The data mode (i.e., 3 bytes).
    It must be decoded by converting the raw values into a 32-bit unsigned integer value and performing a bitwise AND using the bit mask defined in Table 9.
  • DATA ACQUISITION FREQUENCY
    The frequency of log for the file (i.e., 1 byte, the hex code representing the selected frequency).

Otherwise, an acknowledge message with ERROR CODE = 0x01 is returned.

² It corresponds to Sunday 26 January 2020 00:53:20.

5.6.3 File Download

The file download command can be executed in write-only mode. The HEX code is 0x22.

To start the file download procedure given a specific file identifier, the following command must be composed.

TRANSMISSION

RESPONSE

• FILE ID
  The files are retrieved passing an index (i.e., between 0 and N-1, where N is the number of files currently stored in the system) as the command argument.
• CHANNEL
  It allows to select the communication channel to be used (i.e., USB, 0x00, or BLE, 0x01).
• FILE SIZE
  It is a 32-bit unsigned integer value that represents the file size in bytes.

If all run successfully, the system moves into the READOUT state. The user MUST send an ACK message to effectively start the data streaming.

TRANSMISSION

The ack sent by the user follows the same ack format of every other command: the first byte of the payload is used to indicate the command that triggered the ack (0x22 in this case), and the second byte is used to signify an ACK (0x00) or NACK (any other number).

In the case of BLE channel selection, the file will be transmitted 128 bytes at a time through notification on Data Characteristic. Every 2048 bytes received (i.e., 16 notifications), an ACK message is required. The flow is mostly the same as the USB, but carried out via Bluetooth: the firmware will move into the readout state, waiting for an ack before starting the data offload. After the first ack is received, the firmware will perform unconfirmed notifications (i.e., 128 bytes) to transmit the page (i.e., 2048 bytes), then will wait for a user ACK. As before, if the user sends a NACK, the same page will be retransmitted; otherwise, the next page will begin transmission with the same procedure. The last page will probably be completely transmitted with less than 16 notifications, but the user must send the ack at the end of the process anyway to return the system in the idle state.