FeitCSI

https://feitcsi.kuskosoft.com
Admin
FeitCSI is an open-source 802.11 CSI extraction and injection tool supporting all formats...
Tokens:12,254
Snippets:113
Trust Score:6.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install FeitCSI-iwlwifi .deb Package

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Install the downloaded FeitCSI-iwlwifi .deb package using apt or dpkg. The installer uses dkms to automatically recompile the driver when the kernel is updated.

```bash
sudo apt install ./feitcsi-iwlwifi_2.0.0_all.deb
# or
sudo dpkg -i ./feitcsi-iwlwifi_2.0.0_all.deb
```

--------------------------------

### Install FeitCSI .deb Package

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Install the downloaded FeitCSI .deb package using apt or dpkg. This command installs the main FeitCSI program, which communicates with the custom driver.

```bash
sudo apt install ./feitcsi_2.0.0_all.deb
# or
sudo dpkg -i ./feitcsi_2.0.0_all.deb
```

--------------------------------

### Compile FeitCSI-iwlwifi Driver from Source

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Clone the FeitCSI-iwlwifi repository, navigate to the directory, configure the build, compile, and install the driver. This process requires the linux-headers to be installed.

```bash
git clone https://github.com/KuskoSoft/FeitCSI-iwlwifi.git
cd FeitCSI-iwlwifi
make defconfig-iwlwifi-public
make
sudo make install
```

--------------------------------

### Install Generic Linux Headers

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Install the generic linux-headers package required for compiling the FeitCSI-iwlwifi driver. This command is for Debian-based systems.

```bash
sudo apt install linux-headers-generic
```

--------------------------------

### Compile FeitCSI Program from Source

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Clone the FeitCSI repository, navigate to the directory, compile the program using make, and then install it. This process requires the necessary development dependencies to be installed first.

```bash
git clone https://github.com/KuskoSoft/FeitCSI.git
cd FeitCSI
make
sudo make install
```

--------------------------------

### Start FeitCSI systemd Service

Source: https://feitcsi.kuskosoft.com/udp_socket

Command to manually start the FeitCSI systemd service.

```bash
sudo systemctl start feitcsi

```

--------------------------------

### Install FeitCSI Program Dependencies

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Install the necessary development libraries for compiling the main FeitCSI program. These dependencies are required before cloning and building the source code.

```bash
sudo apt install libgtkmm-3.0-dev libnl-genl-3-dev libiw-dev libpcap-dev
```

--------------------------------

### Start FTM Initiator

Source: https://feitcsi.kuskosoft.com/examples

Begin FTM ranging as an initiator targeting a specific MAC address. The `--ftm-asap` flag attempts to start the ranging process immediately.

```bash
feitcsi --mode ftm --frequency 2412 --format HT --channel-width 20 --ftm-mac 00:11:22:33:44:56 --ftm-asap -v
```

--------------------------------

### Download FeitCSI-iwlwifi .deb Package

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Download the latest .deb package for the FeitCSI-iwlwifi driver. This package simplifies installation by including dependencies and automating compilation.

```bash
wget https://github.com/KuskoSoft/FeitCSI/releases/download/v2.0.0/feitcsi-iwlwifi_2.0.0_all.deb
```

--------------------------------

### Enable FeitCSI systemd Service

Source: https://feitcsi.kuskosoft.com/udp_socket

Command to enable the FeitCSI systemd service, ensuring it starts automatically on system startup.

```bash
sudo systemctl enable feitcsi

```

--------------------------------

### FeitCSI systemd Service Configuration

Source: https://feitcsi.kuskosoft.com/udp_socket

This configuration file sets up FeitCSI to run as a systemd service, allowing it to start automatically on system boot. It ensures the service starts after the network is online and restarts automatically if it fails.

```systemd
# /etc/systemd/system/feitcsi.service
[Unit]
Description=FeitCSI service
After=network-online.target
Wants=network-online.target systemd-networkd-wait-online.service

StartLimitIntervalSec=500
StartLimitBurst=10

[Service]
Restart=on-failure
RestartSec=5s

ExecStart=/usr/local/bin/feitcsi --udp-socket

[Install]
WantedBy=multi-user.target

```

--------------------------------

### Start FTM Responder

Source: https://feitcsi.kuskosoft.com/examples

Initiate the FTM responder mode with a specified MAC address. This is used for devices that will respond to FTM ranging requests.

```bash
feitcsi --mode ftmres --frequency 2412 --format HT --channel-width 20 --mac 00:11:22:33:44:56 -v
```

--------------------------------

### Start FTM Responder and Inject Frames

Source: https://feitcsi.kuskosoft.com/examples

Configure the device as an FTM responder and inject frames in switching mode. This is useful for testing how a responder handles injected traffic while participating in FTM. The default interval for switching mode is 3000ms.

```bash
feitcsi --mode injectftmres --frequency 2412 --format HT --channel-width 20 --mac 00:11:22:33:44:56 -v
```

--------------------------------

### Download FeitCSI .deb Package

Source: https://feitcsi.kuskosoft.com/installation_and_upgrade

Download the latest .deb package for the main FeitCSI program. This package provides a convenient way to install the program without manual compilation.

```bash
wget https://github.com/KuskoSoft/FeitCSI/releases/download/v2.0.0/feitcsi_2.0.0_all.deb
```

--------------------------------

### Start FTM Initiator and Measure CSI

Source: https://feitcsi.kuskosoft.com/examples

Initiate FTM ranging and simultaneously measure CSI in a switching mode. This allows for analysis of signal conditions during ranging. The default interval for switching mode is 3000ms.

```bash
feitcsi --mode measureftm --frequency 2412 --format HT --channel-width 20 --ftm-mac 00:11:22:33:44:56 --ftm-asap -v
```

--------------------------------

### MATLAB UDP Socket Example for Frame Injection and Extraction

Source: https://feitcsi.kuskosoft.com/udp_socket

This MATLAB script demonstrates how to use UDP sockets to inject frames from one device and extract CSI data on another. Ensure FeitCSI is running in UDP socket mode on both devices. The script configures transmitter and receiver IPs, frequency, channel width, and other parameters before sending commands and reading data.

```matlab
% SETTINGS START
TRANSMITTER_IP = "192.168.0.240";
RECEIVER_IP = "192.168.0.241";
FREQUENCY = "2412";
CHANNEL_WIDTH = "20";
FRAME_FORMAT = "HT";
MCS_INDEX = "0";
INJECT_DELAY = "100000"; %in microseconds, time between frames
TX_POWER = "1"; %in dBm
% SETTINGS END

udpReceiver = udpport("datagram");
udpReceiver.Timeout = 60;

udpTransmitter = udpport("datagram");
udpTransmitter.Timeout = 60;

write(udpTransmitter,"stop","uint8",TRANSMITTER_IP,8008);
write(udpTransmitter,sprintf("feitcsi --frequency %s --channel-width %s --format %s --mcs %s --inject-delay %s --tx-power %s --mode inject", FREQUENCY, CHANNEL_WIDTH, FRAME_FORMAT, MCS_INDEX, INJECT_DELAY, TX_POWER),"uint8",TRANSMITTER_IP,8008);

write(udpReceiver,"stop","uint8",RECEIVER_IP,8008);
write(udpReceiver,sprintf("feitcsi --frequency %s --channel-width %s --format %s", FREQUENCY, CHANNEL_WIDTH, FRAME_FORMAT),"uint8",RECEIVER_IP,8008);


for i = 1:10 % receive  10 csi
    raw_datas = read(udpReceiver, 1);
    raw_csi_bytes = uint8(raw_data.Data);
    % parse raw_csi_bytes data, example is in FeitCSI parsing scripts page
end

% stop injecting/extracting
write(udpTransmitter,"stop","uint8",TRANSMITTER_IP,8008);
write(udpReceiver,"stop","uint8",RECEIVER_IP,8008);

```

--------------------------------

### Run Application in GUI Mode

Source: https://feitcsi.kuskosoft.com/graphical_user_interface

To launch the application with its graphical user interface, use the '--gui' flag.

```bash
feitcsi --gui

```

--------------------------------

### Main CSI Data Reading Loop in MATLAB

Source: https://feitcsi.kuskosoft.com/matlab

Reads CSI data from a file, parses header and CSI matrix for each entry, and stores the results. This loop processes the file sequentially, advancing by the size of the header and CSI data for each record.

```matlab
    f = fopen(fileName);
    fileContent = uint8(fread(f));
    step = 1;
    index = 1;
    while length(fileContent) > step
        data = {};
        data.header = parseHeader(fileContent(step:step + 271));
        step = step + 272;
        data.csi_matrix = parseCsiData(fileContent(step:step+data.header.csi_size - 1), data.header);
        step = step + data.header.csi_size;
        output(index ) = data;
        index  = index  + 1;
    end
end
```

--------------------------------

### Pseudocode for Parsing CSI Data File

Source: https://feitcsi.kuskosoft.com/csi_format

This pseudocode outlines the process of iterating through a FeitCSI data file, parsing the header and CSI data for each measurement block.

```pseudocode
for (i = fileSize; i < fileSize; i += step)
    header = parseHeader( file[i:i+272] );
    csiData = parseCsi( file[i+272; header.sizeOfCsiData] );
    step = 272 + header.sizeOfCsiData;
end for

```

--------------------------------

### Python Script for Parsing FeitCSI Data

Source: https://feitcsi.kuskosoft.com/python

This script parses FeitCSI data from a specified file. It defines constants for rate and channel width flags and includes a function to parse the header information from the binary data.

```python

'''
Function which parse FeitCSI data.
usage: parseFeitCSI("path/to/FeitCSI/file")
returned data structure sample:
[
    {
        header: {
            "csi_size":416,
            "ftm_clock":144084200,
            "timestamp":1701251234567890,
            "num_rx":2,
            "num_tx":1,
            "num_subcarriers":52,
            "rssi1":67,
            "rssi2":68,
            "source_mac":(0, 7, 14, 124, 232, 48),
            "source_mac_string":"00:07:0e:7c:e8:30",
            "rate_flags":49415,
            "rate_format":"LEGACY_OFDM",
            "channel_width":"20",
            "mcs":7,
            "antenna_a":true,
            "antenna_b":true,
            "ldpc":false,
            "ss":1,
            "beamforming":false
        },
        data: complex matrix[num_subcarriers, num_rx, num_tx]
    },
    {
        header: ...,
        data: ...
    }, 
    ...
]
'''
import numpy as np
import struct


def parseFeitCSI(fileName):
    RATE_MCS_MOD_TYPE_POS = 8
    RATE_MCS_MOD_TYPE_MSK = (0x7 << RATE_MCS_MOD_TYPE_POS)
    RATE_MCS_CCK_MSK = (0 << RATE_MCS_MOD_TYPE_POS)
    RATE_MCS_LEGACY_OFDM_MSK = (1 << RATE_MCS_MOD_TYPE_POS)
    RATE_MCS_HT_MSK = (2 << RATE_MCS_MOD_TYPE_POS)
    RATE_MCS_VHT_MSK = (3 << RATE_MCS_MOD_TYPE_POS)
    RATE_MCS_HE_MSK = (4 << RATE_MCS_MOD_TYPE_POS)
    RATE_MCS_EHT_MSK = (5 << RATE_MCS_MOD_TYPE_POS)
    RATE_MCS_CHAN_WIDTH_POS = 11
    RATE_MCS_CHAN_WIDTH_MSK = (0x7 << RATE_MCS_CHAN_WIDTH_POS)
    RATE_MCS_CHAN_WIDTH_20_VAL = 0
    RATE_MCS_CHAN_WIDTH_20 = (RATE_MCS_CHAN_WIDTH_20_VAL << RATE_MCS_CHAN_WIDTH_POS)
    RATE_MCS_CHAN_WIDTH_40_VAL = 1
    RATE_MCS_CHAN_WIDTH_40 = (RATE_MCS_CHAN_WIDTH_40_VAL << RATE_MCS_CHAN_WIDTH_POS)
    RATE_MCS_CHAN_WIDTH_80_VAL = 2
    RATE_MCS_CHAN_WIDTH_80 = (RATE_MCS_CHAN_WIDTH_80_VAL << RATE_MCS_CHAN_WIDTH_POS)
    RATE_MCS_CHAN_WIDTH_160_VAL = 3
    RATE_MCS_CHAN_WIDTH_160 = (RATE_MCS_CHAN_WIDTH_160_VAL << RATE_MCS_CHAN_WIDTH_POS)
    RATE_MCS_CHAN_WIDTH_320_VAL = 4
    RATE_MCS_CHAN_WIDTH_320 = (RATE_MCS_CHAN_WIDTH_320_VAL << RATE_MCS_CHAN_WIDTH_POS)
    RATE_HT_MCS_CODE_MSK = 7
    RATE_MCS_ANT_A_POS = 14
    RATE_MCS_ANT_A_MSK = (1 << RATE_MCS_ANT_A_POS)
    RATE_MCS_ANT_B_POS = 15
    RATE_MCS_ANT_B_MSK = (1 << RATE_MCS_ANT_B_POS)
    RATE_MCS_LDPC_POS = 16
    RATE_MCS_LDPC_MSK = (1 << RATE_MCS_LDPC_POS)
    RATE_MCS_SS_POS = 16
    RATE_MCS_SS_MSK = (1 << RATE_MCS_SS_POS)
    RATE_MCS_BEAMF_POS = 16
    RATE_MCS_BEAMF_MSK = (1 << RATE_MCS_BEAMF_POS)

    with open(fileName, mode='rb') as file:
        def parseHeader(data):
            header = {}
            header["csi_size"] = struct.unpack("I", data[0:4])[0]
            header["ftm_clock"] = struct.unpack("I", data[8:12])[0]
            header["timestamp"] = struct.unpack("Q", data[12:20])[0]
            header["num_rx"] = data[46]
            header["num_tx"] = data[47]
            header["num_subcarriers"] = struct.unpack("I", data[52:56])[0]
            header["rssi1"] = struct.unpack("I", data[60:64])[0]
            header["rssi2"] = struct.unpack("I", data[64:68])[0]
            header["source_mac"] = struct.unpack("BBBBBB", data[68:74])
            header["source_mac_string"] = "%02x:%02x:%02x:%02x:%02x:%02x" % struct.unpack("BBBBBB", data[68:74])
            header["rate_flags"] = struct.unpack("I", data[92:96])[0]

            rate_format = header["rate_flags"] & RATE_MCS_MOD_TYPE_MSK
            if rate_format == RATE_MCS_CCK_MSK:
                rate_format = "CCK"
            elif rate_format == RATE_MCS_LEGACY_OFDM_MSK:
                rate_format = "LEGACY_OFDM"
            elif rate_format == RATE_MCS_VHT_MSK:
                rate_format = "VHT"
            elif rate_format == RATE_MCS_HT_MSK:
                rate_format = "HT"
            elif rate_format == RATE_MCS_HE_MSK:
                rate_format = "HE"
            elif rate_format == RATE_MCS_EHT_MSK:
                rate_format = "EHT"
            else:
                rate_format = "unknown"
            header["rate_format"] = rate_format

            channel_width = header["rate_flags"] & RATE_MCS_CHAN_WIDTH_MSK
            if channel_width == RATE_MCS_CHAN_WIDTH_20:
                channel_width = "20"
            elif channel_width == RATE_MCS_CHAN_WIDTH_40:
                channel_width = "40"
            elif channel_width == RATE_MCS_CHAN_WIDTH_80:
                channel_width = "80"
            elif channel_width == RATE_MCS_CHAN_WIDTH_160:
                channel_width = "160"
            elif channel_width == RATE_MCS_CHAN_WIDTH_320:
                channel_width = "320"
            else:
                channel_width = "unknown"
            header["channel_width"] = channel_width

            header["mcs"] = header["rate_flags"] & RATE_HT_MCS_CODE_MSK
            header["antenna_a"] = True if header["rate_flags"] & RATE_MCS_ANT_A_MSK else False
            header["antenna_b"] = True if header["rate_flags"] & RATE_MCS_ANT_B_MSK else False

```

--------------------------------

### Inject VHT Frames with Repetition

Source: https://feitcsi.kuskosoft.com/examples

Inject VHT frames at a specific frequency and channel width with a defined delay between injections and a set number of repetitions. Useful for testing frame handling under specific traffic patterns.

```bash
feitcsi --mode inject --frequency 5260 --channel-width 80 --format VHT --inject-delay 5000 --inject-repeat 11 -v
```

--------------------------------

### MATLAB Script for Parsing FeitCSI Data

Source: https://feitcsi.kuskosoft.com/matlab

This script defines a function to parse FeitCSI files. It includes extensive bitwise operations to decode header information such as CSI size, timestamps, and rate flags, determining modulation type, channel width, and antenna configurations.

```matlab
%{ 
Function which parse FeitCSI data.
usage: parseFeitCSI("path/to/FeitCSI/file")
returned data structure sample:
[
    {
        header: {
            "csi_size":416,
            "ftm_clock":144084200,
            "timestamp":1701251234567890,
            "num_rx":2,
            "num_tx":1,
            "num_subcarriers":52,
            "rssi1":67,
            "rssi2":68,
            "source_mac":(0, 7, 14, 124, 232, 48),
            "source_mac_string":"00:07:0e:7c:e8:30",
            "rate_flags":49415,
            "rate_format":"LEGACY_OFDM",
            "channel_width":"20",
            "mcs":7,
            "antenna_a":true,
            "antenna_b":true,
            "ldpc":false,
            "ss":1,
            "beamforming":false
        },
        data: complex matrix[num_subcarriers, num_rx, num_tx]
    },
    {
        header: ...,
        data: ...
    }, 
    ...
]
%}

function output = parseFeitCSI(fileName)
    RATE_MCS_MOD_TYPE_POS = uint32(8);
    RATE_MCS_MOD_TYPE_MSK = bitshift(uint32(0x7), RATE_MCS_MOD_TYPE_POS);
    RATE_MCS_CCK_MSK = bitshift(uint32(0), RATE_MCS_MOD_TYPE_POS);
    RATE_MCS_LEGACY_OFDM_MSK = bitshift(uint32(1), RATE_MCS_MOD_TYPE_POS);
    RATE_MCS_HT_MSK = bitshift(uint32(2), RATE_MCS_MOD_TYPE_POS);
    RATE_MCS_VHT_MSK = bitshift(uint32(3), RATE_MCS_MOD_TYPE_POS);
    RATE_MCS_HE_MSK = bitshift(uint32(4), RATE_MCS_MOD_TYPE_POS);
    RATE_MCS_EHT_MSK = bitshift(uint32(5), RATE_MCS_MOD_TYPE_POS);
    RATE_MCS_CHAN_WIDTH_POS = uint32(11);
    RATE_MCS_CHAN_WIDTH_MSK = bitshift(uint32(0x7), RATE_MCS_CHAN_WIDTH_POS);
    RATE_MCS_CHAN_WIDTH_20_VAL = uint32(0);
    RATE_MCS_CHAN_WIDTH_20 = bitshift(RATE_MCS_CHAN_WIDTH_20_VAL, RATE_MCS_CHAN_WIDTH_POS);
    RATE_MCS_CHAN_WIDTH_40_VAL = uint32(1);
    RATE_MCS_CHAN_WIDTH_40 = bitshift(RATE_MCS_CHAN_WIDTH_40_VAL, RATE_MCS_CHAN_WIDTH_POS);
    RATE_MCS_CHAN_WIDTH_80_VAL = uint32(2);
    RATE_MCS_CHAN_WIDTH_80 = bitshift(RATE_MCS_CHAN_WIDTH_80_VAL, RATE_MCS_CHAN_WIDTH_POS);
    RATE_MCS_CHAN_WIDTH_160_VAL = uint32(3);
    RATE_MCS_CHAN_WIDTH_160 = bitshift(RATE_MCS_CHAN_WIDTH_160_VAL, RATE_MCS_CHAN_WIDTH_POS);
    RATE_MCS_CHAN_WIDTH_320_VAL = uint32(4);
    RATE_MCS_CHAN_WIDTH_320 = bitshift(RATE_MCS_CHAN_WIDTH_320_VAL, RATE_MCS_CHAN_WIDTH_POS);
    RATE_HT_MCS_CODE_MSK = uint32(7);
    RATE_MCS_ANT_A_POS = uint32(14);
    RATE_MCS_ANT_A_MSK = bitshift(uint32(1), RATE_MCS_ANT_A_POS);
    RATE_MCS_ANT_B_POS = uint32(15);
    RATE_MCS_ANT_B_MSK = bitshift(uint32(1), RATE_MCS_ANT_B_POS);
    RATE_MCS_LDPC_POS = uint32(16);
    RATE_MCS_LDPC_MSK = bitshift(uint32(1), RATE_MCS_LDPC_POS);
    RATE_MCS_SS_POS = uint32(16);
    RATE_MCS_SS_MSK = bitshift(uint32(1), RATE_MCS_SS_POS);
    RATE_MCS_BEAMF_POS = uint32(16);
    RATE_MCS_BEAMF_MSK = bitshift(uint32(1), RATE_MCS_BEAMF_POS);

    function header = parseHeader(data)
        header = {};
        header.csi_size = typecast(data(1:4), 'uint32');
        header.ftm_clock = typecast(data(9:12), 'uint32');
        header.timestamp = typecast(data(13:20), 'uint64');
        header.num_rx = data(47);
        header.num_tx = data(48);
        header.num_subcarriers = typecast(data(53:56), 'uint32');
        header.rssi1 = typecast(data(61:64), 'uint32');
        header.rssi2 = typecast(data(65:68), 'uint32');
        header.source_mac = data(69:74);
        header.source_mac_string = sprintf('%02x:%02x:%02x:%02x:%02x:%02x', header.source_mac);
        header.rate_flags = typecast(data(93:96), 'uint32');

        rate_format = bitand(header.rate_flags, RATE_MCS_MOD_TYPE_MSK);
        if rate_format == RATE_MCS_CCK_MSK
            rate_format = 'CCK';
        elseif rate_format == RATE_MCS_LEGACY_OFDM_MSK
            rate_format = 'LEGACY_OFDM';
        elseif rate_format == RATE_MCS_VHT_MSK
            rate_format = 'VHT';
        elseif rate_format == RATE_MCS_HT_MSK
            rate_format = 'HT';
        elseif rate_format == RATE_MCS_HE_MSK
            rate_format = 'HE';
        elseif rate_format == RATE_MCS_EHT_MSK
            rate_format = 'EHT';
        else
            rate_format = 'unknown';
        end
        header.rate_format = rate_format;

        channel_width = bitand(header.rate_flags, RATE_MCS_CHAN_WIDTH_MSK);
        if channel_width == RATE_MCS_CHAN_WIDTH_20
            channel_width = '20';
        elseif channel_width == RATE_MCS_CHAN_WIDTH_40
            channel_width = '40';
        elseif channel_width == RATE_MCS_CHAN_WIDTH_80
            channel_width = '80';
        elseif channel_width == RATE_MCS_CHAN_WIDTH_160
            channel_width = '160';
        elseif channel_width == RATE_MCS_CHAN_WIDTH_320
            channel_width = '320';
        else
            channel_width = 'unknown';
        end
        header.channel_width = channel_width;

        header.mcs = bitand(header.rate_flags, RATE_HT_MCS_CODE_MSK);

        if bitand(header.rate_flags, RATE_MCS_ANT_A_MSK)
            header.antenna_a = true;

```

--------------------------------

### Measure CSI and Inject HT Frames

Source: https://feitcsi.kuskosoft.com/examples

Perform both CSI measurement and HT frame injection simultaneously. This mode is useful for correlating signal quality with frame transmission behavior.

```bash
feitcsi --mode measureinject --frequency 2412 --channel-width 20 --format HT --inject-delay 10000 --inject-repeat 133 -v
```

--------------------------------

### Parse FTM Data File

Source: https://feitcsi.kuskosoft.com/ftm_format

Iterates through a file, parsing 79-byte FTM data blocks sequentially. Assumes a fixed block size for parsing.

```pseudocode
for (i = fileSize; i < fileSize; i += step)
    ftmData = parseFtm( file[i:i+79] );
    step = 79;
end for

```

--------------------------------

### BibTeX Citation for FeitCSI Project

Source: https://feitcsi.kuskosoft.com/

This snippet provides the BibTeX entry for citing the FeitCSI project in academic publications. Ensure this is included when referencing FeitCSI in your research.

```bibtex
@electronic{feitcsi:project,
    author = {Hutar, Miroslav and Brida, Peter and Machaj, Juraj},
    title = {FeitCSI, the 802.11 CSI tool},
    url = {https://feitcsi.kuskosoft.com},
    year = {2023}
}
```

--------------------------------

### Measure CSI of 802.11ax Packets

Source: https://feitcsi.kuskosoft.com/examples

Measure CSI for 802.11ax packets on a specified frequency and channel width, saving the output to a file. Use this for detailed signal analysis.

```bash
feitcsi --frequency 5180 --channel-width 160 --format HESU --output-file csi.dat -v
```

--------------------------------

### Parse CSI Header Flags in MATLAB

Source: https://feitcsi.kuskosoft.com/matlab

Parses various flags from the CSI header, such as antenna configuration, LDPC, and beamforming status. This logic is applied conditionally based on bitwise AND operations.

```matlab
        else    
            header.antenna_a = false;
        end

        if bitand(header.rate_flags, RATE_MCS_ANT_B_MSK)
            header.antenna_b = true;
        else    
            header.antenna_b = false;
        end

        if bitand(header.rate_flags, RATE_MCS_LDPC_MSK)
            header.ldpc = true;
        else    
            header.ldpc = false;
        end

        if bitand(header.rate_flags, RATE_MCS_SS_MSK)
            header.ss = 2;
        else    
            header.ss = 1;
        end

        if bitand(header.rate_flags, RATE_MCS_BEAMF_MSK)
            header.beamforming = true;
        else    
            header.beamforming = false;
        end

    end
```

--------------------------------

### Parse FeitCSI FTM Data

Source: https://feitcsi.kuskosoft.com/python

This Python function parses a binary file containing FeitCSI FTM data. It reads the file byte by byte, unpacks the data according to a predefined structure, and returns a list of dictionaries, where each dictionary holds FTM measurement details for a burst. Ensure the input `fileName` points to a valid FTM data file.

```python
'''
Function which parse FeitCSI FTM data.
usage: parseFeitCSIftm("path/to/FeitCSI/ftm/file")
returned data structure sample:
[
    {
        "burstIndex": 123,
        "numFtmrAttempts": 123,
        "numFtmrSuccesses": 123,
        "numBurstsExp": 123,
        "burstDuration": 123,
        "ftmsPerBurst": 123,
        "rssiAvg": 123,
        "rssiSpread": 123,
        "rttAvg": 123,
        "rttVariance": 123,
        "rttSpread": 123,
        "distAvg": 123,
        "distVariance": 123,
        "distSpread": 123,
        "timestamp": 123,
    },
    {
        FTM data...
    }, 
    ...
]
'''
import numpy as np
import struct


def parseFeitCSIftm(fileName):
    with open(fileName, mode='rb') as file:
        def parseFtmData(data):
            ftmData = {}
            ftmData["burstIndex"] = struct.unpack("I", data[0:4])[0]
            ftmData["numFtmrAttempts"] = struct.unpack("I", data[4:8])[0]
            ftmData["numFtmrSuccesses"] = struct.unpack("I", data[8:12])[0]
            ftmData["numBurstsExp"] = struct.unpack("I", data[12:16])[0]
            ftmData["burstDuration"] = data[16]
            ftmData["ftmsPerBurst"] = data[17]
            ftmData["rssiAvg"] = data[18]
            ftmData["rssiSpread"] = struct.unpack("I", data[19:23])[0]
            ftmData["rttAvg"] = struct.unpack("Q", data[23:31])[0]
            ftmData["rttVariance"] = struct.unpack("Q", data[31:39])[0]
            ftmData["rttSpread"] = struct.unpack("Q", data[39:47])[0]
            ftmData["distAvg"] = struct.unpack("Q", data[47:55])[0]
            ftmData["distVariance"] = struct.unpack("Q", data[55:63])[0]
            ftmData["distSpread"] = struct.unpack("Q", data[63:71])[0]
            ftmData["timestamp"] = struct.unpack("Q", data[71:79])[0]

            return ftmData

        fileContent = file.read()
        step = 0
        output = []
        while (len(fileContent) > step):
            data = parseFtmData(fileContent[step:(step+79)])
            step += 79
            output.append(data)
        return output

```

--------------------------------

### MATLAB Script to Parse FeitCSI FTM Data

Source: https://feitcsi.kuskosoft.com/matlab

This script parses a binary FTM file, extracting burst index, attempt counts, durations, signal strength, RTT, distance, and timestamps. It uses a helper function to decode each 79-byte FTM record.

```matlab
%{
Function which parse FeitCSI FTM data.
usage: parseFeitCSIftm("path/to/FeitCSI/ftm/file")
returned data structure sample:
[
    {
        "burstIndex": 123,
        "numFtmrAttempts": 123,
        "numFtmrSuccesses": 123,
        "numBurstsExp": 123,
        "burstDuration": 123,
        "ftmsPerBurst": 123,
        "rssiAvg": 123,
        "rssiSpread": 123,
        "rttAvg": 123,
        "rttVariance": 123,
        "rttSpread": 123,
        "distAvg": 123,
        "distVariance": 123,
        "distSpread": 123,
        "timestamp": 123,
    },
    {
        FTM data...
    },
    ...
]
%}

function output = parseFeitCSIftm(fileName)

    function ftmData = parseFtmData(data)
        ftmData = {};
        ftmData.burstIndex = typecast(data(1:4), 'uint32');
        ftmData.numFtmrAttempts = typecast(data(5:8), 'uint32');
        ftmData.numFtmrSuccesses = typecast(data(9:12), 'uint32');
        ftmData.numBurstsExp = typecast(data(13:16), 'uint32');
        ftmData.burstDuration = typecast(data(17), 'uint8');
        ftmData.ftmsPerBurst = typecast(data(18), 'uint8');
        ftmData.rssiAvg = typecast(data(19), 'uint8');
        ftmData.rssiSpread = typecast(data(20:23), 'uint32');
        ftmData.rttAvg = typecast(data(24:31), 'uint64');
        ftmData.rttVariance = typecast(data(32:39), 'uint64');
        ftmData.rttSpread = typecast(data(40:47), 'uint64');
        ftmData.distAvg = typecast(data(48:55), 'uint64');
        ftmData.distVariance = typecast(data(56:63), 'uint64');
        ftmData.distSpread = typecast(data(64:71), 'uint64');
        ftmData.timestamp = typecast(data(72:79), 'uint64');
    end

    f = fopen(fileName);
    fileContent = uint8(fread(f));
    step = 1;
    index = 1;
    while length(fileContent) > step
        ftmData = parseFtmData(fileContent(step:step + 78));
        step = step + 79;
        output(index) = ftmData;
        index  = index  + 1;
    end
end

```

--------------------------------

### Parse CSI Matrix Data in MATLAB

Source: https://feitcsi.kuskosoft.com/matlab

Parses the complex CSI matrix from raw data. It iterates through subcarriers, receive, and transmit antennas, extracting real and imaginary parts of complex numbers.

```matlab
    function csi_matrix = parseCsiData(data, header)
        csi_matrix = zeros(header.num_subcarriers, header.num_rx, header.num_tx);
        csi_matrix  = complex(csi_matrix ,0);
        pos = 1;
        for j = 1:header.num_rx
            for k = 1:header.num_tx
                for n = 1:header.num_subcarriers
                    real = typecast(data(pos:pos + 1), 'int16');
                    imag = typecast(data(pos + 2:pos + 3), 'int16');
                    pos = pos + 4;
                    csi_matrix(n, j, k) = complex(real, imag);
                end
            end
        end
    end
```

--------------------------------

### Parse CSI Header and Data

Source: https://feitcsi.kuskosoft.com/python

Parses CSI data from a file, extracting header information and the CSI matrix. This function processes the file content in chunks, returning a list of parsed data structures.

```python
def parseHeader(header_bytes):
            header = {}
            header["rate_flags"] = struct.unpack("I", header_bytes[0:4])[0]
            header["csi_size"] = struct.unpack("I", header_bytes[4:8])[0]
            header["num_subcarriers"] = struct.unpack("H", header_bytes[8:10])[0]
            header["num_rx"] = struct.unpack("B", header_bytes[10:11])[0]
            header["num_tx"] = struct.unpack("B", header_bytes[11:12])[0]
            header["reserved"] = struct.unpack("16x", header_bytes[12:28])[0]
            header["timestamp"] = struct.unpack("d", header_bytes[28:36])[0]
            header["noise_power"] = struct.unpack("f", header_bytes[36:40])[0]
            header["gain"] = struct.unpack("f", header_bytes[40:44])[0]
            header["reserved2"] = struct.unpack("128x", header_bytes[44:172])[0]
            header["antenna_sel"] = struct.unpack("B", header_bytes[172:173])[0]
            header["phy_info"] = struct.unpack("12x", header_bytes[173:185])[0]
            header["rate_flags"] = struct.unpack("I", header_bytes[185:189])[0]
            header["avg_spatial_stream"] = struct.unpack("f", header_bytes[189:193])[0]
            header["max_spatial_stream"] = struct.unpack("f", header_bytes[193:197])[0]
            header["avg_burst_time"] = struct.unpack("f", header_bytes[197:201])[0]
            header["max_burst_time"] = struct.unpack("f", header_bytes[201:205])[0]
            header["avg_payload_len"] = struct.unpack("f", header_bytes[205:209])[0]
            header["max_payload_len"] = struct.unpack("f", header_bytes[209:213])[0]
            header["avg_payload_bw"] = struct.unpack("f", header_bytes[213:217])[0]
            header["max_payload_bw"] = struct.unpack("f", header_bytes[217:221])[0]
            header["avg_payload_mcs"] = struct.unpack("f", header_bytes[221:225])[0]
            header["max_payload_mcs"] = struct.unpack("f", header_bytes[225:229])[0]
            header["avg_payload_nss"] = struct.unpack("f", header_bytes[229:233])[0]
            header["max_payload_nss"] = struct.unpack("f", header_bytes[233:237])[0]
            header["avg_payload_nsts"] = struct.unpack("f", header_bytes[237:241])[0]
            header["max_payload_nsts"] = struct.unpack("f", header_bytes[241:245])[0]
            header["avg_payload_beamforming"] = struct.unpack("f", header_bytes[245:249])[0]
            header["max_payload_beamforming"] = struct.unpack("f", header_bytes[249:253])[0]
            header["avg_payload_rssi"] = struct.unpack("f", header_bytes[253:257])[0]
            header["max_payload_rssi"] = struct.unpack("f", header_bytes[257:261])[0]
            header["avg_payload_rssi_without_beamforming"] = struct.unpack("f", header_bytes[261:265])[0]
            header["max_payload_rssi_without_beamforming"] = struct.unpack("f", header_bytes[265:269])[0]
            header["avg_payload_rssi_with_beamforming"] = struct.unpack("f", header_bytes[269:273])[0]
            header["max_payload_rssi_with_beamforming"] = struct.unpack("f", header_bytes[273:277])[0]

            header["ldpc"] = True if header["rate_flags"] & RATE_MCS_LDPC_MSK else False
            header["ss"] = 2 if header["rate_flags"] & RATE_MCS_SS_MSK else 1
            header["beamforming"] = True if header["rate_flags"] & RATE_MCS_BEAMF_MSK else False

            return header

        def parseCsiData(data, header):
            csi_matrix = np.zeros((header["num_subcarriers"], header["num_rx"], header["num_tx"] ), dtype=complex)
            pos = 0
            for j in range(header["num_rx"]):
                for k in range(header["num_tx"]):
                    for n in range(header["num_subcarriers"]):
                        real = struct.unpack("h", data[pos:pos + 2])[0]
                        imag = struct.unpack("h", data[pos + 2:pos + 4])[0]
                        pos += 4
                        csi_matrix[n, j, k] = complex(real, imag)
            return csi_matrix

        fileContent = file.read()
        step = 0
        output = []
        while (len(fileContent) > step):
            data = {}
            data["header"] = parseHeader(fileContent[step:(step+272)])
            step += 272
            data["csi_matrix"] = parseCsiData(fileContent[step:(step + data["header"]["csi_size"])], data["header"])
            step += data["header"]["csi_size"]
            output.append(data)
        return output
```
Tokens:
Raw