Linux CSI Tool 完整使用说明（一发一收，monitor模式）（权威版 已成功测试）

置顶 已于 2023-11-14 16:45:34 修改
阅读量1.7w 收藏 163
点赞数 37
文章标签： linux csi matlab wifi
于 2021-05-31 23:26:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/James_Bond_slm/article/details/117432357
版权

文章目录

Linux CSI Tool 完整使用说明（权威版 已成功测试）

本文涉及到的所有文件均在以下百度网盘链接的压缩包内，请大家自取
链接: https://pan.baidu.com/s/1I67ex4KwFnItlyFCoWlQoQ
提取码: ep8b

相关链接：

1. 硬件设备

  1. 电脑设备推荐ThinkPad X201，推荐购买链接：https://item.taobao.com/item.htm?_u=v3mfohc203a6&id=575205451871
  2. 网卡务必使用Intel 5300网卡，推荐购买链接（附赠天线）：https://item.taobao.com/item.htm?spm=a1z09.2.0.0.48192e8dEszrp2&id=572509799776&_u=v3mfohc2b41c

2. 刷BIOS & 拆卸替换网卡

由于ThinkPad X201电脑的BIOS版本比较旧，因此我之前直接换装网卡之后在BIOS启动阶段就出错了，提示无法识别的硬件设备。因此我们需要在换装网卡之前利用Win PE系统刷一遍BIOS。

  1. 准备一个2G左右的U盘，准备PE系统的安装程序：WePE_32_V2.1.exe（压缩包内）

  2. 运行该程序，根据程序的指示将U盘刷成PE系统的启动盘。

  3. 准备 ThinkPad X201 的 BIOS 包：ThinkPad X201_6quj10us_SLIC21_no_whitelist.zip（压缩包内）

  4. 将BIOS包复制到U盘名为“微软PE工具箱”的分区内。

  5. 接下来将U盘插入ThinkPad X201内，启动电源，在出现初始化界面时按ThinkVantage按钮，然后出现选择菜单时按F12，在启动菜单中选择U盘。

  6. 等待进入U盘PE系统，在“微软PE工具箱”分区内解压之前下载的BIOS包，建议选择64位的文件夹（如果64bit刷BIOS失败了用32bit也行），然后双击“WinPhlash64.exe”运行，直接点击flash bios即可。

  7. 等待刷机完成后关闭电脑，接下来是拆卸和换装网卡步骤。

  8. 切断笔记本电源，拔出笔记本电池，切勿带电操作！

  9. 用十字螺丝刀拧开笔记本背面的螺丝（拧开带有键盘、触摸板图标的螺丝即可）

  10. 拧完螺丝后轻轻就可以拆开笔记本的键盘和触摸板。

  11. 原先的网卡在右下方的位置，我们需要用螺丝刀拧开螺丝后才能移除原有网卡，然后才能插入5300网卡。

  12. 由于一般天线是放在笔记本外侧的，所以需要拆除右下方的声卡板来为接线提供空间。

  13. 安装完毕后如下图所示：
    在这里插入图片描述

3. 操作系统

操作系统推荐Ubuntu 14.06 LTS，内核版本为3.13，不过现在好像只能下载到4.4的内核版本（镜像链接：https://mirrors.zju.edu.cn/ubuntu-releases/）

我用的是3.13内核版本的Ubuntu 14.06，问题应该不大，因为后面要重新编译过内核。

怎么安装系统就不说了。相信大家都没有问题。

另外，如果你能在安装系统的界面成功检测到周围的WIFI并且能连接成功，那说明你的BIOS刷机成功了，系统“认识”这款网卡。

不过还是建议大家在连着有线网的情况下安装，包括后续的安装操作。

4. 内核编译、驱动、固件配置

操作系统安装完毕后，重启进入。刚进入系统时可能会提示你是否要升级到16.04，点击否就行了。包括提示要更新软件等都略过吧。

  1. 安装相关依赖

    • 更新源

      sudo apt-get update

    • 下载安装依赖包

      sudo apt-get -y install git-core kernel-package fakeroot build-essential ncurses-dev
sudo apt-get -y install libnl-dev libssl-dev
sudo apt-get -y install iw

  2. 下载、编译内核

    • 准备 intel-5300-csi-github-master.tar.gz

      压缩包内有：intel-5300-csi-github-master.tar.gz，如果觉得百度网盘下载速度慢，这里提供一位博主的：https://download.csdn.net/download/u014645508/10579514

    • 解压、编译

      按顺序一步一步在终端执行以下代码

      cd ~
tar -xvf intel-5300-csi-github-master.tar.gz
cd intel-5300-csi-github-master
make oldconfig # 一直按回车
make menuconfig # 在弹出的窗口选择Save，再Exit，一定要save一遍，而不是直接退出。另外可能会因为终端窗口比较小无法显示完全而报错
make -j4 # 编译内核一直都比较慢，大概半小时到一小时
sudo make install modules_install # 安装kernel module，大约15分钟
sudo make install
sudo make install modules_install # 再次安装内核模块（保险起见，一定要执行）
sudo mkinitramfs -o /boot/initrd.img-`cat include/config/kernel.release` `cat include/config/kernel.release`
make headers_install
sudo mkdir /usr/src/linux-headers-`cat include/config/kernel.release`
sudo cp -rf usr/include /usr/src/linux-headers-`cat include/config/kernel.release`/include

    • 添加刚刚编译过的内核（4.2.0版本）至启动项

      cd /etc/default
sudo vi grub

      注释这一行

      GRUB_HIDDEN_TIMEOUT=0

    • 更新grub

      sudo update-grub

    • 重启电脑，一定要在启动选项中选择4.2的内核版本进入。

  3. 替换固件

    按顺序在终端执行以下代码

    cd ~
git clone https://github.com/dhalperi/linux-80211n-csitool-supplementary.git
for file in /lib/firmware/iwlwifi-5000-*.ucode; do sudo mv $file $file.orig; done
sudo cp linux-80211n-csitool-supplementary/firmware/iwlwifi-5000-2.ucode.sigcomm2010 /lib/firmware/
sudo ln -s iwlwifi-5000-2.ucode.sigcomm2010 /lib/firmware/iwlwifi-5000-2.ucode

    到此，5300网卡的驱动以及CSI收发包工具都已经配置完毕。接下来分别介绍发包和收包的操作。

5. 具体使用

5.1 共同准备

在终端按顺序执行以下代码

cd ~
sudo apt-get install libpcap-dev
git clone https://github.com/dhalperi/lorcon-old.git
cd lorcon-old
./configure
make
sudo make install

5.2 CSI发送端

  1. 编译发送代码

    cd ~
cd linux-80211n-csitool-supplementary/injection/
make

  2. 执行初始化脚本 inject.sh（压缩包内：inject.sh）

    在执行之前建议先查看无线网卡接口名称，一般情况下是 wlan0

    iwconfig

    如图所示：
    在这里插入图片描述
    执行脚本即参数配置：

    sudo bash ./inject.sh wlan0 64 HT20

    参数解释：第一个参数是无线网卡接口名称，一般是wlan0，第二个参数是信道编号，建议64，第三个是OFDM下的HT20模式

    inject.sh代码：

    #!/usr/bin/sudo /bin/bash
sudo service network-manager stop
WLAN_INTERFACE=$1
SLEEP_TIME=2
modprobe iwlwifi debug=0x40000
if [ "$#" -ne 3 ]; then
    echo "Going to use default settings!"
    chn=64
    bw=HT20
else
    chn=$2
    bw=$3
fi
sleep $SLEEP_TIME
ifconfig $WLAN_INTERFACE 2>/dev/null 1>/dev/null
while [ $? -ne 0 ]
do
    ifconfig $WLAN_INTERFACE 2>/dev/null 1>/dev/null
done
sleep $SLEEP_TIME
echo "Add monitor mon0....."
iw dev $WLAN_INTERFACE interface add mon0 type monitor
sleep $SLEEP_TIME
echo "Bringing $WLAN_INTERFACE down....."
ifconfig $WLAN_INTERFACE down
while [ $? -ne 0 ]
do
    ifconfig $WLAN_INTERFACE down
done
sleep $SLEEP_TIME
echo "Bringing mon0 up....."
ifconfig mon0 up
while [ $? -ne 0 ]
do
    ifconfig mon0 up
done
sleep $SLEEP_TIME
echo "Set channel $chn $bw....."
iw mon0 set channel $chn $bw

  3. 发送数据

    echo 0x1c113 | sudo tee `sudo find /sys -name monitor_tx_rate`
cd ~
cd linux-80211n-csitool-supplementary/injection/
sudo ./random_packets 1000000000 100 1 1000

    第一行的参数配置如果有个人需求可以参考：CSI Tool安装使用讲解

    不过个人建议就这样就行了，毕竟这个工具搭建很麻烦。

    random_packets的参数解释：第一个参数是累计发包数量，第二个参数是包的大小，第三个参数1代表injection MAC，用1就可以了，最后一个参数代表每隔1000微秒发一次包，即一秒发1000个包。

5.3 CSI接收端

  1. 编译接收代码

    cd ~
cd linux-80211n-csitool-supplementary/netlink/
make

  2. 执行初始化脚本 monitor.sh （压缩包内：monitor.sh）

    注意：一定要采用这个脚本，其他博客上的脚本基本缺少了第2、3行内容，否则收不到包的！我尝试了好几次，才找到办法。如果发现此脚本运行后提示找不到对应的wlan接口也可尝试另外一个，感谢粉丝“qq_45884215”提供的资源

    sudo bash ./monitor.sh wlan0 64 HT20

    信道编号要和发送端的一样

    monitor.sh代码

    #!/usr/bin/sudo /bin/bash
sudo modprobe -r iwlwifi mac80211
sudo modprobe iwlwifi connector_log=0x1

sudo service network-manager stop
SLEEP_TIME=2
WLAN_INTERFACE=$1
if [ "$#" -ne 3 ]; then
	echo "Going to use default settings!"
	chn=64
	bw=HT20
else
	chn=$2
	bw=$3
fi
echo "Bringing $WLAN_INTERFACE down......"
ifconfig $WLANINTERFACE down
while [ $? -ne 0 ]
do
	ifconfig $WLAN_INTERFACE down
done
sleep $SLEEP_TIME
echo "Set $WLAN_INTERFACE into monitor mode......"
iwconfig $WLAN_INTERFACE mode monitor
while [ $? -ne 0 ]
do
	iwconfig $WLAN_INTERFACE mode monitor
done
sleep $SLEEP_TIME
echo "Bringing $WLAN_INTERFACE up......"
ifconfig $WLAN_INTERFACE up
while [ $? -ne 0 ]
do
	ifconfig $WLAN_INTERFACE up
done
sleep $SLEEP_TIME
echo "Set channel $chn $bw..."
iw $WLAN_INTERFACE set channel $chn $bw

monitor.sh 备用代码
请添加图片描述

  1. 执行收包程序

    cd ~
cd linux-80211n-csitool-supplementary/netlink/
sudo ./log_to_file temp # temp是保存数据的文件名，强烈建议文件名改为dat后缀

    由于原生的代码只能不停的收包，因此我编写了一个可以收包n秒以后自动停止的C代码（压缩包内：log_to_file.c）：

    使用方法如下：

    cd ~
cd linux-80211n-csitool-supplementary/netlink/
sudo ./log_to_file temp 3

    参数解释：temp是保存数据的文件名，3代表从检测到CSI包之后收3秒，然后退出程序。如果发送端每秒发送1000个包，那么在不丢包的情况下可以收到3000个包。如下图：
    在这里插入图片描述

    log_to_file.c 文件代码：

    /*
 * (c) 2008-2011 Daniel Halperin <dhalperi@cs.washington.edu>
 */
#include "iwl_connector.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <linux/netlink.h>

#define MAX_PAYLOAD 2048
#define SLOW_MSG_CNT 100

int sock_fd = -1; // the socket
FILE *out = NULL;

void check_usage(int argc, char **argv);

FILE *open_file(char *filename, char *spec);

void caught_signal(int sig);

void exit_program(int code);
void exit_program_err(int code, char *func);
void exit_program_with_alarm(int sig);

int main(int argc, char **argv)
{
	/* Local variables */
	struct sockaddr_nl proc_addr, kern_addr; // addrs for recv, send, bind
	struct cn_msg *cmsg;
	char buf[4096];
	int ret;
	unsigned short l, l2;
	int count = 0;

	/* Initialize signal*/
	signal(SIGALRM, exit_program_with_alarm);

	/* Make sure usage is correct */
	check_usage(argc, argv);

	/* Open and check log file */
	out = open_file(argv[1], "w");

	/* Setup the socket */
	sock_fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
	if (sock_fd == -1)
		exit_program_err(-1, "socket");

	/* Initialize the address structs */
	memset(&proc_addr, 0, sizeof(struct sockaddr_nl));
	proc_addr.nl_family = AF_NETLINK;
	proc_addr.nl_pid = getpid(); // this process' PID
	proc_addr.nl_groups = CN_IDX_IWLAGN;
	memset(&kern_addr, 0, sizeof(struct sockaddr_nl));
	kern_addr.nl_family = AF_NETLINK;
	kern_addr.nl_pid = 0; // kernel
	kern_addr.nl_groups = CN_IDX_IWLAGN;

	/* Now bind the socket */
	if (bind(sock_fd, (struct sockaddr *)&proc_addr, sizeof(struct sockaddr_nl)) == -1)
		exit_program_err(-1, "bind");

	/* And subscribe to netlink group */
	{
		int on = proc_addr.nl_groups;
		ret = setsockopt(sock_fd, 270, NETLINK_ADD_MEMBERSHIP, &on, sizeof(on));
		if (ret)
			exit_program_err(-1, "setsockopt");
	}

	/* Set up the "caught_signal" function as this program's sig handler */
	signal(SIGINT, caught_signal);

	/* Poll socket forever waiting for a message */
	while (1)
	{
		/* Receive from socket with infinite timeout */
		ret = recv(sock_fd, buf, sizeof(buf), 0);
		if (ret == -1)
			exit_program_err(-1, "recv");
		/* Pull out the message portion and print some stats */
		cmsg = NLMSG_DATA(buf);
		if (count % SLOW_MSG_CNT == 0)
			printf("received %d bytes: counts: %d id: %d val: %d seq: %d clen: %d\n", cmsg->len, count, cmsg->id.idx, cmsg->id.val, cmsg->seq, cmsg->len);
		/* Log the data to file */
		l = (unsigned short)cmsg->len;
		l2 = htons(l);
		fwrite(&l2, 1, sizeof(unsigned short), out);
		ret = fwrite(cmsg->data, 1, l, out);
		++count;
		if (count == 1)
		{
			/* Set alarm */
			alarm((*argv[2] - '0'));
		}
		if (ret != l)
			exit_program_err(1, "fwrite");
	}

	exit_program(0);
	return 0;
}

void check_usage(int argc, char **argv)
{
	if (argc != 3)
	{
		fprintf(stderr, "Usage: %s <output_file> <time>\n", argv[0]);
		exit_program(1);
	}
}

FILE *open_file(char *filename, char *spec)
{
	FILE *fp = fopen(filename, spec);
	if (!fp)
	{
		perror("fopen");
		exit_program(1);
	}
	return fp;
}

void caught_signal(int sig)
{
	fprintf(stderr, "Caught signal %d\n", sig);
	exit_program(0);
}

void exit_program(int code)
{
	if (out)
	{
		fclose(out);
		out = NULL;
	}
	if (sock_fd != -1)
	{
		close(sock_fd);
		sock_fd = -1;
	}
	exit(code);
}

void exit_program_err(int code, char *func)
{
	perror(func);
	exit_program(code);
}

void exit_program_with_alarm(int sig)
{
	exit_program(0);
}

6. CSI数据处理（Matlab & Python)

Matlab和Python都可以对数据进行处理。个人推荐Matlab，更权威，Python的处理结果貌似和Matlab不一样。

这两种方式都可以将dat格式的原数据转化为csv格式。因为我采用的收发都是3根天线，每根天线都有30个子载波，一秒钟3000个包，所以最后csv的数据维度是3000 * （30 * 3 * 3）即3000 * 270的大小。

6.1 Matlab方式

  1. 下载Matlab处理dat文件的代码包。（压缩包内：01 dat_to_csi_mat.zip）

  2. 运行代码包内的data_to_csi.m脚本。

    data_to_csi.m:

    csi_file = read_bf_file('temp.dat');
row = size(csi_file, 1);
temp = [];

for k = 1:row
    csi = get_scaled_csi(csi_file{k});
    csi = csi(:)';

    for m = 1:length(csi)
        csi(m) = abs(csi(m));
    end

    temp = [temp; csi];
end

writematrix(temp, 'output.csv');

6.2 Python方式

直接运行以下Python代码，注意文件路径等参数修改为自己的

import numpy as np
import math


class Bfee:

    def __init__(self):
        pass

    @staticmethod
    def from_file(filename, model_name_encode="shift-JIS"):

        with open(filename, "rb") as f:
            from functools import reduce
            # reduce(函数，list)，将list中元素依次累加
            array = bytes(reduce(lambda x, y: x+y, list(f)))

        bfee = Bfee()

#         vmd.current_index = 0
        bfee.file_len = len(array)
        bfee.dicts = []
        bfee.all_csi = []

#         vmd.timestamp_low0 = int.from_bytes(array[3:7], byteorder='little', signed=False)

#         array = array[3:]

        # %% Initialize variables
        # ret = cell(ceil(len/95),1);    # % Holds the return values - 1x1 CSI is 95 bytes big, so this should be upper bound
        cur = 0                       # % Current offset into file
        count = 0                    # % Number of records output
        broken_perm = 0              # % Flag marking whether we've encountered a broken CSI yet
        # % What perm should sum to for 1,2,3 antennas
        triangle = [0, 1, 3]

        while cur < (bfee.file_len - 3):
            # % Read size and code
            # % 将文件数据读取到维度为 sizeA 的数组 A 中，并将文件指针定位到最后读取的值之后。fread 按列顺序填充 A。
            bfee.field_len = int.from_bytes(
                array[cur:cur+2], byteorder='big', signed=False)
            bfee.code = array[cur+2]
            cur = cur+3

            # there is CSI in field if code == 187，If unhandled code skip (seek over) the record and continue
            if bfee.code == 187:
                pass
            else:
                # % skip all other info
                cur = cur + bfee.field_len - 1
                continue

            # get beamforming or phy data
            if bfee.code == 187:
                count = count + 1

                bfee.timestamp_low = int.from_bytes(
                    array[cur:cur+4], byteorder='little', signed=False)
                bfee.bfee_count = int.from_bytes(
                    array[cur+4:cur+6], byteorder='little', signed=False)
                bfee.Nrx = array[cur+8]
                bfee.Ntx = array[cur+9]
                bfee.rssi_a = array[cur+10]
                bfee.rssi_b = array[cur+11]
                bfee.rssi_c = array[cur+12]
                bfee.noise = array[cur+13] - 256
                bfee.agc = array[cur+14]
                bfee.antenna_sel = array[cur+15]
                bfee.len = int.from_bytes(
                    array[cur+16:cur+18], byteorder='little', signed=False)
                bfee.fake_rate_n_flags = int.from_bytes(
                    array[cur+18:cur+20], byteorder='little', signed=False)
                bfee.calc_len = (
                    30 * (bfee.Nrx * bfee.Ntx * 8 * 2 + 3) + 6) / 8
                bfee.csi = np.zeros(
                    shape=(30, bfee.Nrx, bfee.Ntx), dtype=np.dtype(np.complex))
                bfee.perm = [1, 2, 3]
                bfee.perm[0] = ((bfee.antenna_sel) & 0x3)
                bfee.perm[1] = ((bfee.antenna_sel >> 2) & 0x3)
                bfee.perm[2] = ((bfee.antenna_sel >> 4) & 0x3)

                cur = cur + 20

                # get payload
                payload = array[cur:cur+bfee.len]
                cur = cur + bfee.len

                index = 0

                # Check that length matches what it should
                if (bfee.len != bfee.calc_len):
                    print("MIMOToolbox:read_bfee_new:size",
                          "Wrong beamforming matrix size.")

                # Compute CSI from all this crap :
                # import struct
                for i in range(30):
                    index += 3
                    remainder = index % 8
                    for j in range(bfee.Nrx):
                        for k in range(bfee.Ntx):
                            real_bin = bytes([(payload[int(index / 8)] >> remainder) | (
                                payload[int(index/8+1)] << (8-remainder)) & 0b11111111])
                            real = int.from_bytes(
                                real_bin, byteorder='little', signed=True)
                            imag_bin = bytes([(payload[int(index / 8+1)] >> remainder) | (
                                payload[int(index/8+2)] << (8-remainder)) & 0b11111111])
                            imag = int.from_bytes(
                                imag_bin, byteorder='little', signed=True)
                            tmp = np.complex(float(real), float(imag))
                            bfee.csi[i, j, k] = tmp
                            index += 16

                # % matrix does not contain default values
                if sum(bfee.perm) != triangle[bfee.Nrx-1]:
                    print('WARN ONCE: Found CSI (', filename, ') with Nrx=',
                          bfee.Nrx, ' and invalid perm=[', bfee.perm, ']\n')
                else:
                    temp_csi = np.zeros(
                        bfee.csi.shape, dtype=np.dtype(np.complex))
                    # bfee.csi[:,bfee.perm[0:bfee.Nrx],:] = bfee.csi[:,0:bfee.Nrx,:]
                    for r in range(bfee.Nrx):
                        temp_csi[:, bfee.perm[r], :] = bfee.csi[:, r, :]
                    bfee.csi = temp_csi
                # 将类属性导出为dict，并返回
                bfee_dict = {}
                bfee_dict['timestamp_low'] = bfee.timestamp_low
                bfee_dict['bfee_count'] = bfee.bfee_count
                bfee_dict['Nrx'] = bfee.Nrx
                bfee_dict['Ntx'] = bfee.Ntx
                bfee_dict['rssi_a'] = bfee.rssi_a
                bfee_dict['rssi_b'] = bfee.rssi_b
                bfee_dict['rssi_c'] = bfee.rssi_c
                bfee_dict['noise'] = bfee.noise
                bfee_dict['agc'] = bfee.agc
                bfee_dict['antenna_sel'] = bfee.antenna_sel
                bfee_dict['perm'] = bfee.perm
                bfee_dict['len'] = bfee.len
                bfee_dict['fake_rate_n_flags'] = bfee.fake_rate_n_flags
                bfee_dict['calc_len'] = bfee.calc_len
                bfee_dict['csi'] = bfee.csi

                bfee.dicts.append(bfee_dict)
                bfee.all_csi.append(bfee.csi)

        return bfee


def db(X, U):
    R = 1
    if 'power'.startswith(U):
        assert X >= 0
    else:
        X = math.pow(abs(X), 2) / R

    return (10 * math.log10(X) + 300) - 300


def dbinv(x):
    return math.pow(10, x / 10)


def get_total_rss(csi_st):
    # Careful here: rssis could be zero
    rssi_mag = 0
    if csi_st['rssi_a'] != 0:
        rssi_mag = rssi_mag + dbinv(csi_st['rssi_a'])
    if csi_st['rssi_b'] != 0:
        rssi_mag = rssi_mag + dbinv(csi_st['rssi_b'])
    if csi_st['rssi_c'] != 0:
        rssi_mag = rssi_mag + dbinv(csi_st['rssi_c'])
    return db(rssi_mag, 'power') - 44 - csi_st['agc']


def get_scale_csi(csi_st):
    # Pull out csi
    csi = csi_st['csi']
    # print(csi.shape)
    # print(csi)
    # Calculate the scale factor between normalized CSI and RSSI (mW)
    csi_sq = np.multiply(csi, np.conj(csi)).real
    csi_pwr = np.sum(csi_sq, axis=0)
    csi_pwr = csi_pwr.reshape(1, csi_pwr.shape[0], -1)
    rssi_pwr = dbinv(get_total_rss(csi_st))

    scale = rssi_pwr / (csi_pwr / 30)

    if csi_st['noise'] == -127:
        noise_db = -92
    else:
        noise_db = csi_st['noise']
    thermal_noise_pwr = dbinv(noise_db)

    quant_error_pwr = scale * (csi_st['Nrx'] * csi_st['Ntx'])

    total_noise_pwr = thermal_noise_pwr + quant_error_pwr
    ret = csi * np.sqrt(scale / total_noise_pwr)
    if csi_st['Ntx'] == 2:
        ret = ret * math.sqrt(2)
    elif csi_st['Ntx'] == 3:
        ret = ret * math.sqrt(dbinv(4.5))
    return ret


written_data = ''

bfee = Bfee.from_file('temp.dat', model_name_encode="gb2312")
for k in range(len(bfee.all_csi)):
    csi = get_scale_csi(bfee.dicts[k])

    for a in range(30):
        for b in range(3):
            for c in range(3):
                temp = abs(csi[a][b][c])
                written_data += str(temp) + ','
    written_data = written_data[: len(written_data) - 1] + '\n'
written_data = written_data[: len(written_data) - 1]

file = open('output.csv', mode='w')
file.write(written_data)
file.close()
Genshin_Doge
关注
  • 37
    点赞
  • 踩
  • 163
    收藏
    觉得还不错? 一键收藏
  • 207
    评论
从零开始的Linux 802.11WiFi CSITool（AP和monitor模式均亲测可用）
konacyan的博客
01-07 9410
从零开始的Linux WiFi CSITool主要参考零、Linux及CSI相关知识的学习1.Linux相关**1.1 视频教程：****1.2 文字教程：**2.CSI 相关2.1 **IEEE 802.11n协议：****2.2 CSI简介：**一、Ubuntu安装1.下载Ubuntu2.制作启动盘（注意备份）3.打开新电脑的BIOS设置4.继续开机，安装Ubuntu5.换apt源5.1 **备份**：5.2 **编辑list文件**：5.3 **将source.list中的内容替换**5.4 **更
CSI Tool 集成安装包(适配Ubuntu11.04)
04-17
CSI Tool 集成安装包(适配Ubuntu 11.04系统，Intel 5300 无线网卡) csitools
linux-80211n-csitool-supplementary-master.zip_CSITool_Linux-supp
09-24
采集信道状态信息，哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈
WiFi信道状态信息 基于Intel 5300的CSI Tool 安装及使用（一）
热门推荐
Silver_777的博客
07-13 1万+
经过半个月的坎坷安装过程，连Windows系统都没装过的本人终于颤颤巍巍把CSI TOOL装好了，下面记录一下适于我所使用设备的安装过程。设备：一台THINKPAD X201，一台师兄借的华硕主板的台式机首先，如果你和我一样对linux其实一窍不通的话，建议先反复看教程里的安装代码，照猫画虎很难一步实现的，中途一定会有这或那的问题需要解决，所以该了解的基础linux指令还是要了解，起码安装过程中的那些指令可以去查一查。.........
Linux 无线WIFI搜索带信号强度，使用nmcli或iw
最新发布
FREEDOM_X的专栏
06-27 1093
以往我都是在linux的系统中都是通过配置文件来配置和修改ip的，今天我们就来说一说nmcli命令配置网络。目前所有的linux系统配置网卡等信息，均已经推行Network-Manager服务去管理。nmcli 是 NetworkManager 的命令行工具。nm 代表 NetworkManager，cli 代表 Command-Line 命令行。
Thinkpad X201 linux csi tool搭建一收一发搭建笔记（2023年7月26日）
qq_44108731的博客
07-26 642
然后有一步 make 编译的时候会有提示 Can’t read private key ，不要理会，官方也说了没事：https://dhalperi.github.io/linux-80211n-csitool/installation.html。中间第三步下载的速度是比较慢的，毕竟是从 github 上面下载 1个多 G 的文件，我原本以为速度很慢，但其实还好，1个小时左右就可以搞定。如果网卡出现了yes，说明被锁了，不能使用，需要在笔记本电脑的左下侧边，有一个滑动按钮，滑到绿色，重新启动电脑即可。
CSI简析（二）
程序不爱猿
03-13 4226
       在第一篇博客中，简单的介绍了一下什么是CSI，在这篇博客中，用matlab软件对采集到的CSI信息进行一下简单的解析。只需要将原始的CSI数据读取到一个元胞数组中，然后在命令行窗口中显示即可。                                  timestamp_low: NIC网卡1MHz时钟的低32位    bfee_count：驱动记录并发送到用户控件的波束测量...
最新Linux CSI Tools安装教程（两台主机，一发一收）（监控模式）
h1998040218的博客
12-22 933
无线感知之CSI Tools工具安装，最新在监控模式下采集CSI数据，
CSI Tool 安装及配置记录
二十年蝉电子学习博客
02-13 2244
csi tool
CSI TOOL安装(实现AP 和monitor模式)
yangzhiyuan88的博客
01-08 1031
CSI TOOL安装(实现AP 和monitor模式)
Linux CSI Tool 完整使用说明，终结解决方案（一发一收，monitor模式，wifi发收单台，ap模式）（权威版 已成功测试）
wangxu14574630的博客
05-01 1420
特推出monitor ap模式x201终结解决方案，附带详细执行指令，学生按照指令就可以进行csi wifi人体行为识别实验，免除摸索时间精力浪费，学生可以专心研究信号分析。monitor模式如果自行安装学生自己摸索实际预估花费2个月左右，ap模式安装预估半个月左右。特别说明：ap模式执行指令和monitor模式执行指令需要搭配完整解决方案设备才能正常使用。3. 准备一台路由器，通电，不要设置密码。注意：输入各命令字母正确和中间空格，确保命令正常执行。说明：需要搭配完整解决方案设备，命令才能正常执行。
2023/10.9-台式机搭建5300网卡收集csi数据
qq_45884215的博客
10-09 3389
查看是否有输出，有则成功，ctrl+c停止收发，在netlink文件夹看到csi.dat数据，需要把数据单独保存，下一次收发会清空上次的数据。1、购买带有天线的5300网卡（半高卡适合笔记本，全高卡适合台式电脑）和一台路由器，利用无线网卡外置天线构成天线阵列，用于接收无线信道数据并传给搭建5300网卡的电脑上。3、两台电脑一台收一台发，安装CSI Tools 的主机需要连接 wifi，这里另开终端就是为了模拟其它主机向路由器发信号，我们的 CSI 能不能察觉到。1、5300网卡（半高）
CSI Tool 监控模式下双向CSI采集（同时发送并接收数据）.zip
01-02
嵌入式相关的项目源码、数据集等资源
WinPhlash64
08-18
这个工具让我找了好久好久，相信那些想要刷新BIOS 却一直在使用64位系统的朋友应该会很需要的吧。该工具本人已经测试过 完全可以使用 呵呵
[原创]Linux 802.11n CSI tool Monitor模式-附件资源
03-02
[原创]Linux 802.11n CSI tool Monitor模式-附件资源
linux-80211n-csitool-supplementary.zip_CSITool_CSI信道状态_csi数据预处理_
07-14
标题中的“linux-80211n-csitool-supplementary.zip”是一个压缩包文件，主要涉及的内容是“CSITool”，它是一个用于处理802.11n无线网络中“CSI（Channel State Information）”信道状态信息的工具。这个工具在...
Linux CSI Tool 安装和使用说明
Acecai01的博客模板
03-10 1646
配置基于intel 5300网卡进行WiFi数据采集的环境
推荐文章：Linux-80211n-CSITool - 带您走进无线网络测试的新世界
gitblog_00055的博客
03-14 398
推荐文章：Linux-80211n-CSITool - 带您走进无线网络测试的新世界 项目简介 Linux-80211n-CSITool 是一个开源的 Linux 内核模块，它提供了一种方便、高效的方法来收集和分析 802.11n 无线网络设备的频道状态信息（Channel State Information，简称 CSI）。该项目由 David Halperin 发起，并在 GitCode 上开...
搭建WiFi感知环境-基于Ubuntu 14.04.3+Intel 5300 Tools+matlab2016b安装
qq_42438350的博客
02-21 1324
搭建WiFi感知环境-基于Ubuntu 14.04.3+Intel 5300 Tools+matlab2016b安装
csi tool monitor
01-18
CSI工具监控是一种用于对计算机系统和网络进行安全监控的工具。它可以实时监控系统中的各种活动，包括文件访问、系统日志、进程运行等，以便及时发现潜在的安全威胁。CSI工具监控还可以对网络流量进行分析，识别异常活动和攻击行为。通过对监控数据的收集和分析，可以帮助管理员及时发现并应对系统漏洞和安全威胁，保障计算机系统和网络的安全。 CSI工具监控通常具有图形化界面，方便管理员查看监控数据和生成报告。它还可以设定报警机制，当监控到异常行为时，立即发送警报通知管理员，以便及时处理安全事件。另外，一些CSI工具监控还提供了日志记录功能，可以对监控数据进行长期存储和分析，帮助管理员了解系统的安全状况和漏洞趋势。 总之，CSI工具监控是一种非常重要的安全工具，能够帮助管理员及时发现和应对潜在的安全威胁，保障计算机系统和网络的安全。在当前信息安全形势日趋严峻的情况下，CSI工具监控的作用愈发凸显，将在计算机系统和网络安全管理中发挥越来越重要的作用。
评论 207
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值