# pip和conda换源命令行
pip和conda默认使用的下载链接一般是国外，导致下载速度十分缓慢，以下是换源命令，更换国内的下载源可以更快的下载包。



## pip换源

```csharp
pip config set global.index-url https://pypi.mirrors.ustc.edu.cn/simple/
```

注：尽量使用中科大的源，而不是清华的，中科大的速度大约是清华的10倍左右

## conda换源

在.condarc隐藏文件中覆盖写入：

```text
channels:
  - https://mirrors.ustc.edu.cn/anaconda/pkgs/main/
  - https://mirrors.ustc.edu.cn/anaconda/pkgs/free/
  - https://mirrors.ustc.edu.cn/anaconda/cloud/conda-forge/
ssl_verify: true
```

pip和conda换源

# pandas 常用操作
本文写于大二，由于原博客网站到期，文章尘封已久。现重新排版，对文章进行勘误和加入新的内容。

pandas是一个python的数据处理库，一般搭配numpy使用。在pandas当中数据被抽象成excel表格，使用一种
Dataframe的数据类型。类似一个excel表格，有列名，有索引。经常我们会访问某一列的数据，直接使用列名就可以访问 Dataframe['longitude'], 不过返回的是Series类的数据 ，为了方便操作，可以使用data.values直接转换成 数组类型.（很方便配合matpylotlib绘图！！！）大部分的函数操作都是围绕表格的行或列进行操作，以下是总结的一些常用函数操作。不必记住，需要的时候查询即可。



## 读取数据

通常数据储存在csv或者excel中，调用数据集如下：

```python
import pandas as pd   # 导入模块

data = pd.read_csv()  # 读取csv

data2 = pd.read_excel()  # 读取xls 或者 xlsx
```

## 查看数据信息

```python
print(data.shape)     # 查看数据的维度

print(data.info())    # 查看数据的基本信息

print(data.head())    # 查看数据的前五行

print(data.tail(10))    #查看末尾的10行
 
print(data.isnull())  # 查看所有数据是否有空值，有则为True

print(data.columns)   # 查看数据的所有列名称（不常用）

print(data['longitude'].unique())  # 查看某‘longitude’列唯一数据
```

## 清洗数据

### 填充与替换数据

```python
pd.fillna(value=0) # 将空值用0填充

data['prince'].fillna(df['prince'].mean()) # 用该列的平均数填充该列的空值，或者用其它值填充

data['city'].replace('sh', 'shanghai') # 某列数据替换，将sh替换成shanghai
```

### 提取或去除特定的数据

```python

#筛选符合条件的数据 ！！！很常用
DataFrame2['latitude'].max()      #取某列的最值
 
DataFrame2 = DataFrame[(DataFrame['timestamp'] > "2019-01-03 UTC") & (DataFrame['timestamp']<"2019-01-04 UTC")]
    
 #根据时间去筛选的，每个约束条件需要用括号，约束条件的关系 可以使用 "&" 或者 "|" 表示
 
tmp = tmp.drop_duplicates('carsList')  #筛选某列重复的数据 ！ 可以多个列名
res = DataFrame.drop_duplicates(['latitude', 'longitude'])   #多个列名 经纬度都相同的重复数据会被清洗(and 的重复逻辑，都要重复才会被删除)

tmp['carsList'].count()  #计算某列的非空数据量

res = DataFrame.duplicated(['latitude', 'longitude', 'carsList'])  #返回一个series的布尔数据，重复的数据为True

print(df[result])  提取重复的数据 ，逻辑为真的返回dataframe
```

| index | a    | b    |
| ----- | ---- | ---- |
| 0     | 1    | 1    |
| 1     | 1    | 2    |
| 2     | 3    | 2    |

去除存在列数据一样的行后：

| index | a    | b    |
| ----- | ---- | ---- |
| 1     | 1    | 2    |
| 2     | 3    | 2    |

实现代码：

```python
df = pd.DataFrame(dic)
(df)
(df.loc[~(df[] == df[])])
```

## 大文件处理

涉及到一些数据量略大一点，用pd.read_csv()读取数据似乎比较慢，经过测试 使用hdf5文件类型速度快大约10倍。 除此之外，将数据保存为pickle格式（二进制），读取速度也是非常快。

将dataframe保存为h5格式

```python
store = pd.HDFStore("E:\\gps2020_9.h5")
store['df'] = data    # data是 dataframe
store.close()
```

读取h5格式的文件

```python
data = pd.read_hdf(hdf_fp, key='df')           # key是自己指定的 ,键的值可以自定义  类似与metadata 比较像namespace
```

## 时间处理

关于pandas时间处理， 由于很多数据带有时间字段， 通常会提取某段时间数据，除了上面提到的方法，还可以通过pandas的api转换object的类型为 datetime.datetime

```python
data['RECDATETIME'] = pd.to_datetime(data['RECDATETIME'])
```

关于时间戳转换问题，需要将正常时间转换为unix时间戳。

第一种：

```
data['RECDATETIME'] = pd.to_datetime(data['RECDATETIME']).map(pd.Timestamp.timestamp)
```

第二种：

```
['RECDATETIME'] = (data['RECDATETIME'].astype(int)/10**9).astype('int')
```

## 分类处理

pandas 分类处理： 有时候数据需要根据某个字段名分类，比如全校的成绩表，根据班级不同分班处理

```python
group = data.groupby('STATIONSEQNUM')       # 根据 stationseqnum分类 实际上可以传入一个列表，根据多字段分类
lon = group['LONGITUDE'].agg([np.mean])     # agg  聚合,得到某类的均值 或者 最值
print(group.groups)                         # 查看分类情况
```

## 数据拼接

dataframe 拼接： 由于用的不多，需要的时候再添加

```python
df = pd.concat([lon, lat], axis=1)        # 按列拼接
df = pd.concat([lon, lat])                # 按行拼接
```

注意 ： pd.contact 不考虑 index 只管拼接 ， merge join这些属于合并，会考虑索引对齐 填充等问题

## 更改列名

```python
df.rename(columns={'mean': 'LONGITUDE', 'mean1': 'LATITUDE'}, inplace=True)
```

## 切片操作

无论是dataframe 还是 serious数据类型都有loc方法，根据index进行切片(默认的index是数字),且两边都是闭区间。 df.loc[row1:row2,col1:col2]  , 注意：使用的是中括号

```python
>>>df
          a         b         c         d
1 -0.172949  0.768195 -0.379333  0.658013
2  0.773844 -0.732390  0.589150  0.395631
3  0.204580 -0.937462  0.916332 -0.424054
4  0.641465  1.603234  1.458837  0.373705
5 -1.204567 -1.188565  1.592697  1.871696
6  0.438288 -0.815811  0.592899  0.793396

>>>print(df.loc['2':'4', 'a'])

2    0.773844
3    0.204580
4    0.641465
Name: a, dtype: float64



# 用于筛选数据
>>>df
   a  b  c
x  1  2  3
y  2  1  3
z  2  4  6

>>>print(df.loc[(df['a']>1) & (df['b']>1)])

   a  b  c
z  2  4  6
```

有时候在处理数据的时候，不小心产生了很多unnmaed列，如果没有作用，会占用不少内存，如果要去除：

```.
data = data.loc[:, ~data.columns.str.contains("^Unnamed")]
```

## 分组排序

根据不同的列进行先后排序，可以先排序‘productid’的字段，再排序时间字段

e.g:

```
data = data.sort_values(by=['PRODUCTID', 'RECDATETIME'])
```

pandas数据处理常用操作

# Conda 环境管理（激活与退出）
conda是一个环境管理软件，可以虚拟化不同的python环境，尤其是对于旧版本的python环境。用户可以自由选择python版本，不需要重复安装不同版本的python解释器。本文简单介绍如何创建、激活和退出当前环境。




创建python 版本为3.8的环境

```bash
conda create --name openmmlab python=3.8 -y
```

激活名为“openmmlab”的虚拟环境

```
conda activate openmmlab
```

退出当前环境

```
conda deactivate
```

删除名为"openmmlab"的环境, -all 参数表示删除所有的附带的安装的库

```
conda remove -n openmmlab --all
```

conda与virtualenv虚拟环境管理

# C++网络编程

​	本文的网络编程指代C++ 套接字程序编写，讲述常用的两种连接TCP和UDP的socket.对应**流式套接字（SOCK_STREAM）,数据报套接字(SOCK_DGRAM)**。当然还有第三种**原始套接字(SOCK_RAW)**，使用较少。

C++使用原始未封装的socket还需要考虑跨平台，windows和linux使用的库并不一样，写法也不一样，但是建立连接的方式和原理是一样的。




## TCP socket连接过程



![socket_tcp.png](/static/img/c6b438d0503dea388f338a6730def913.socket_tcp.webp)
TCP（传输控制协议）是一种面向连接的、可靠的、全双工的传输层协议。但是连接的双方并不是完全平等的，而是分为客户端和服务端。客户端和服务端的初始状态是不同的。上图比较清晰的展示了连接过程，服务端需要四步才能完成初始化进入等待连接，客户端只需要两步。 服务端需要改变socket的监听状态并通过**accept()**阻塞等待客户端的消息。

## UDP socket连接过程



![socket_udp.png](/static/img/b074152a005bb267f88edbfb30cef32f.socket_udp.webp)

UDP（用户数据报协议）是一种无连接的、不可靠的传输层协议，用于在计算机网络中进行简单的、低延迟的数据传输。同样这也是全双工，可以相互通信，但是不需要服务端不需要修改监听状态，客户端也不需要连接，只需要直接发送数据。注意：`recvfrom()` 函数是阻塞的，但是也可以使用超时和非阻塞的方式接收数据，比如可以将接收数据的操作放在一个单独的线程或进程中，使主线程或进程不被阻塞，从而实现并发处理。

## Linux socket编程

### 编程使用的相关库

使用的库【必须】：<arpa/inet.h> <sys/socket.h> <netinet/in.h>

可选的库【坑：实际是必选的close函数在里面有声明，不然无法关闭套接字】：<unistd.h>

`<arpa/inet.h>` 是 C/C++ 编程中的一个头文件，它提供了一些用于 IP 地址转换的函数。主要用于在网络编程中对 IP 地址和端口进行**网络字节序和主机字节序之间的转换**。

这个头文件提供了以下常用函数，这些函数在网络编程中常用于 IP 地址和端口的转换、显示以及配置。在使用这些函数时，请确保正确地处理返回值和错误码，以保证网络数据的正确处理。：

1. `in_addr_t inet_addr(const char *cp);`: 该函数将一个点分十进制字符串表示的 IPv4 地址（如 "192.168.1.1"）转换为 `in_addr_t` 类型的网络字节序表示。`in_addr_t` 是一个 32 位无符号整数类型，用于表示 IPv4 地址。
2. `char *inet_ntoa(struct in_addr in);`: 该函数将一个 `struct in_addr` 结构体表示的 IPv4 地址（以网络字节序存储）转换为点分十进制字符串。`in_addr` 结构体包含一个字段 `s_addr`，表示一个 IPv4 地址。
3. `int inet_pton(int af, const char *src, void *dst);`: 该函数将一个点分十进制字符串表示的 IPv4 或 IPv6 地址（取决于 `af` 参数）转换为网络字节序存储的二进制形式。`af` 参数可以是 `AF_INET`（IPv4）或 `AF_INET6`（IPv6）。
4. `const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);`: 该函数将一个网络字节序存储的 IPv4 或 IPv6 地址（取决于 `af` 参数）转换为点分十进制字符串表示。`af` 参数可以是 `AF_INET`（IPv4）或 `AF_INET6`（IPv6）。



`<sys/socket.h>` 是 C/C++ 编程中的一个头文件，它提供了对套接字（socket）编程的支持。套接字是在网络编程中用于实现进程间通信的一种机制。这个头文件提供了一系列函数和常量，用于创建、绑定、监听、接受、连接、发送和接收套接字数据。通过使用 `<sys/socket.h>` 头文件提供的函数和常量，你可以在网络编程中实现不同类型的套接字通信，包括 TCP 和 UDP 等协议的通信。这个头文件是在进行网络编程时必不可少的重要工具之一。需要注意的是，使用套接字编程需要对网络协议和底层数据传输有一定的了解，同时需要仔细处理返回值和错误码以保证程序的正确性和可靠性。

一些常用的函数和常量包括：

1. **函数：**
   * `socket()`：创建一个套接字。
   * `bind()`：将套接字绑定到一个特定的 IP 地址和端口。
   * `listen()`：开始监听传入的连接请求。
   * `accept()`：接受一个传入的连接请求。
   * `connect()`：与远程套接字建立连接。
   * `send()`：发送数据。
   * `recv()`：接收数据。
2. **常量：**
   * `AF_INET`：IPv4 地址族。
   * `AF_INET6`：IPv6 地址族。
   * `SOCK_STREAM`：面向连接的套接字类型（用于 TCP）。
   * `SOCK_DGRAM`：无连接的套接字类型（用于 UDP）。

`<netinet/in.h>` 头文件通常与 `<sys/socket.h>` 和其他网络编程相关的头文件一起使用，**用于定义和处理网络地址和端口**。它是在进行网络编程时必不可少的重要工具之一。需要注意的是，这些函数主要用于处理 IPv4 地址和端口，如果要处理 IPv6 地址，需要使用 `<netinet/in6.h>` 头文件和相应的数据结构和函数。

主要功能包括：

1. **数据结构定义：**
   * `struct sockaddr_in`：用于表示 IPv4 地址和端口的数据结构。
   * `struct in_addr`：用于表示 IPv4 地址的数据结构。
2. **函数：**
   * `htons()` 和 `ntohs()`：用于主机字节序和网络字节序之间的 16 位整数转换。
   * `htonl()` 和 `ntohl()`：用于主机字节序和网络字节序之间的 32 位整数转换。
   * `inet_addr()`：将点分十进制表示的 IPv4 地址转换为网络字节序的二进制表示。
   * `inet_ntoa()`：将网络字节序的二进制表示的 IPv4 地址转换为点分十进制表示的字符串。



`<unistd.h>` 提供了一组与 POSIX（可移植操作系统接口）标准相关的系统调用（system call）函数和符号常量。这些函数和常量主要用于在操作系统层面进行系统调用和对操作系统提供的一些基本功能进行访问。【设计并行处理的时候可能需要】

一些常用的函数和常量包括：

1. **函数：**
   * `read()`：从文件描述符中读取数据。
   * `write()`：向文件描述符写入数据。
   * `close()`：关闭文件描述符。
   * `fork()`：创建一个新进程（通过复制当前进程）。
   * `exec()`：用于在当前进程中执行新程序。
   * `pipe()`：创建一个管道，用于进程间通信。
   * `getpid()`：获取当前进程的进程ID。
   * `getuid()`：获取当前用户的用户ID。
   * `sleep()`：让当前进程睡眠一段时间。
   * `usleep()`：让当前进程以微秒级别睡眠。
   * `access()`：检查文件或目录的访问权限。
2. **常量：**
   * `STDIN_FILENO`：标准输入文件描述符。
   * `STDOUT_FILENO`：标准输出文件描述符。
   * `STDERR_FILENO`：标准错误输出文件描述符。

### TCP代码详解

服务端完整代码：

```cpp
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <cstring>

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    std::cout << "This is server" << std::endl;
    // socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1) {
        std::cout << "Error: socket" << std::endl;
        return 0;
    }
    // bind
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8000);
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(listenfd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        std::cout << "Error: bind" << std::endl;
        return 0;
    }
    // listen
    if(listen(listenfd, 5) == -1) {
        std::cout << "Error: listen" << std::endl;
        return 0;
    }
    // accept
    int conn;
    char clientIP[INET_ADDRSTRLEN] = "";
    struct sockaddr_in clientAddr;
    socklen_t clientAddrLen = sizeof(clientAddr);
    while (true) {
        std::cout << "...listening" << std::endl;
        conn = accept(listenfd, (struct sockaddr*)&clientAddr, &clientAddrLen);
        if (conn < 0) {
            std::cout << "Error: accept" << std::endl;
            continue;
        }
        inet_ntop(AF_INET, &clientAddr.sin_addr, clientIP, INET_ADDRSTRLEN);
        std::cout << "...connect " << clientIP << ":" << ntohs(clientAddr.sin_port) << std::endl;

        char buf[255];
        while (true) {
            /// 此处数据处理会阻塞主线程，可以使用多线程处理数据，主线程继续accept其它的客户端连接。
            memset(buf, 0, sizeof(buf));
            int len = recv(conn, buf, sizeof(buf), 0);
            buf[len] = '\0';
            if (strcmp(buf, "exit") == 0) {
                std::cout << "...disconnect " << clientIP << ":" << ntohs(clientAddr.sin_port) << std::endl;
                break;
            }
            std::cout << buf << std::endl;
            send(conn, buf, len, 0);
        }
        
        close(conn);
    }
    close(listenfd);
    return 0;
}
```

下文将会截取以上代码的核心片段进行解析，如下：
```cpp
int socket(int domain, int type, int protocol);
```

创建一个socket返回唯一一个表示符

**domain**：指定协议域，或称协议族（family），决定了socket的地址类型。

| 名称             | 含义              | 名称         | 含义                     |
| ---------------- | ----------------- | ------------ | ------------------------ |
| PF_UNIX,PF_LOCAL | 本地通信          | PF_X25       | ITU-T X25 / ISO-8208协议 |
| AF_INET,PF_INET  | IPv4 Internet协议 | PF_AX25      | Amateur radio AX.25      |
| PF_INET6         | IPv6 Internet协议 | PF_ATMPVC    | 原始ATM PVC访问          |
| PF_IPX           | IPX-Novell协议    | PF_APPLETALK | Appletalk                |
| PF_NETLINK       | 内核用户界面设备  | PF_PACKET    | 底层包访问               |

**type**：指定socket类型。

| 名称           | 含义                                                         |
| -------------- | ------------------------------------------------------------ |
| SOCK_STREAM    | Tcp连接，提供序列化的、可靠的、双向连接的字节流。支持带外数据传输 |
| SOCK_DGRAM     | 支持UDP连接（无连接状态的消息）                              |
| SOCK_SEQPACKET | 序列化包，提供一个序列化的、可靠的、双向的基本连接的数据传输通道，数据长度定常。每次调用读系统调用时数据需要将全部数据读出 |
| SOCK_RAW       | RAW类型，提供原始网络协议访问                                |
| SOCK_RDM       | 提供可靠的数据报文，不过可能数据会有乱序                     |
| SOCK_PACKET    | 这是一个专用类型，不能呢过在通用程序中使用                   |

**protocol**：指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议。这个参数一般填入0，会自动选择。

```cpp
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
```

**sockfd**：即要操作的socket描述字，socket()函数的返回值。
**addr**：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同。此处一般将 struct sockaddr_in addr的指针 转换成sockaddr类型的指针。

源码中的结构体定义：

```cpp
// ipv4
struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};
转换后的类型：
/* Structure describing a generic socket address.  */
struct sockaddr
  {
    __SOCKADDR_COMMON (sa_);	/* Common data: address family and length.  */
    char sa_data[14];		/* Address data.  */
  };

/* Internet address. */
struct in_addr {
    uint32_t       s_addr;     /* address in network byte order */
};

// ipv6
struct sockaddr_in6 { 
    sa_family_t     sin6_family;   /* AF_INET6 */ 
    in_port_t       sin6_port;     /* port number */ 
    uint32_t        sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr;     /* IPv6 address */ 
    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */ 
};
struct in6_addr { 
    unsigned char   s6_addr[16];   /* IPv6 address */ 
};

// Unix
#define UNIX_PATH_MAX    108
struct sockaddr_un { 
    sa_family_t sun_family;               /* AF_UNIX */ 
    char        sun_path[UNIX_PATH_MAX];  /* pathname */ 
};
```

```cpp
int listen(int sockfd, int backlog);
```

**sockfd**：即为要监听的socket描述字，
**blacklog**：为相应socket可以排队的最大连接个数。
socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

```cpp
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
```

**sockfd**：为服务器的socket描述字，
**addr**：为指向struct sockaddr *的指针，用于返回客户端的协议地址，
**addrlen**：为协议地址的长度。

**返回值**：由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。

注意：accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

```cpp
send(conn, buf, len, 0);
```

代码解释如下源码的注释：

```cpp
/* Send N bytes of BUF to socket FD.  Returns the number sent or -1.

  This function is a cancellation point and therefore not marked with

  __THROW.  */

extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);

/* Read N bytes into BUF from socket FD.

  Returns the number read or -1 for errors.

  This function is a cancellation point and therefore not marked with

  __THROW.  */

extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
```

###  UDP代码详解

完整的服务端代码：

```cpp
#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h> 

int main() {
    int sockfd;
    struct sockaddr_in serverAddr, clientAddr;
    char buffer[1024];

    // Create UDP socket
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        std::cerr << "Error creating socket." << std::endl;
        return 1;
    }

    // Set up server address
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY; // Accept connections from any IP
    serverAddr.sin_port = htons(12345);      // Port to bind to

    // Bind socket to server address
    if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        std::cerr << "Error binding socket." << std::endl;
        close(sockfd); 
        return 1;
    }

    std::cout << "UDP server is running and waiting for data..." << std::endl;

    while (true) {
        socklen_t clientAddrLen = sizeof(clientAddr);
        // Receive data from client
        ssize_t receivedBytes = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,(struct sockaddr*)&clientAddr, &clientAddrLen);
        if (receivedBytes > 0) {
            buffer[receivedBytes] = '\0';
            std::cout << "Received data from client: " << buffer << std::endl;

            // Send response back to client
            // 也可以不发送，不响应
            sendto(sockfd, buffer, receivedBytes, 0, (struct sockaddr*)&clientAddr, clientAddrLen);
        }
    }

    close(sockfd); // Close the socket before exiting the program
    return 0;
}

```

相比较TCP的服务端，UDP服务端同样需要创建套接字，同样绑定端口。不同在于不需要listen和accept函数的用。直接使用函数recvfrom阻塞当前主线程用于等待接收数据。

差异代码：

```cpp
 ssize_t receivedBytes = recvfrom(sockfd, buffer, sizeof(buffer) , 0,(struct sockaddr*)&clientAddr, &clientAddrLen);

// 源码声明
__fortify_function ssize_t
recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags,
	  __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len)
```

**sockfd**: 用于接收数据的socket标识符

**buffer**: 缓冲区

**n**:缓冲区大小

**flag**:默认填0

**(struct sockaddr*)&clientAddr**: 用于存储客户端sokcet信息的地址（指针）

**&clientAddrLen**： 地址长度

返回值：实际接收的数据量，字节数

udp客户端完整代码：



```cpp

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h> 

int main() {
    int sockfd;
    struct sockaddr_in serverAddr;
    char buffer[1024];

// Create UDP socket
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
    std::cerr << "Error creating socket." << std::endl;
    return 1;
}

// Set up server address
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(12345);  // Server port
inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr); // Server IP address

// Send a message to the server
const char* message = "Hello, UDP Server!";
sendto(sockfd, message, strlen(message), 0, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

// Wait for the server's response
struct sockaddr_in responseAddr;
socklen_t responseAddrLen = sizeof(responseAddr);
ssize_t receivedBytes = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,
                                 (struct sockaddr*)&responseAddr, &responseAddrLen);
if (receivedBytes > 0) {
    buffer[receivedBytes] = '\0';
    std::cout << "Received response from server: " << buffer << std::endl;
} else {
    std::cerr << "Error receiving response from server." << std::endl;
}

close(sockfd); // Close the socket
return 0;
}
```
## Windows socket编程

--待更新

C++ windows网络编程

# 常见雷达类型


1.根据雷达工作频段的不同[**注：雷达工作频率越高，波长越短，雷达的分辨率也会随之提高,探测距离减少：随着雷达工作频率的增加，雷达波束散射和吸收的效应会增加，这会使雷达探测距离减少，对目标反射率敏感：高频信号对目标的反射率更加敏感**]，可以将雷达分为以下几类：




- X波段雷达：工作频段为8-12 GHz，主要用于民航雷达、海上航行雷达等。
- S波段雷达：工作频段为2-4 GHz，主要用于天气雷达、飞机高度测量雷达等。
- C波段雷达：工作频段为4-8 GHz，主要用于空管雷达、舰船雷达等。
- Ku波段雷达：工作频段为12-18 GHz，主要用于卫星雷达、舰船雷达等。
- Ka波段雷达：工作频段为26-40 GHz，主要用于气象雷达、远距离探测雷达等。
- W波段雷达：工作频段为75-110 GHz，主要用于高分辨率雷达成像等。

2.根据雷达的应用领域和功能，可以将雷达分为以下几类：

- 天气雷达：用于气象探测和预报。
- 监视雷达：用于监视目标的位置、速度和方向等信息，如航空雷达、海洋雷达等。
- 战术雷达：用于战争和军事目的，如防空雷达、雷达导弹等。
- **民用雷达：用于民用领域，如车载雷达、安检雷达等。**

3.根据雷达的工作方式，可以将雷达分为以下几类：

- 连续波雷达：发射和接收信号的频率相同，无法测量距离，主要用于速度测量和距离预警。
- 脉冲雷达：通过发射短脉冲信号，接收回波来测量目标距离、速度等信息，主要用于空管雷达、气象雷达等。
- 相控阵雷达：通过调整多个天线的相位和幅度，实现波束的控制和调制，具有高分辨率和目标跟踪能力，主要用于防空雷达、舰船雷达等。

## 自动驾驶使用的雷达

自动驾驶中常用的激光雷达有多种，其中较为常见的是旋转式激光雷达（Rotating LiDAR）和固态激光雷达（Solid-State LiDAR），旋转式激光雷达是一种通过旋转激光发射器和接收器组成的激光雷达，可以360度无死角地扫描周围环境。旋转式激光雷达具有测量精度高、测量距离远等优点，但由于需要旋转机械部件，其体积较大、成本较高。

固态激光雷达则是一种采用固态激光器阵列进行扫描的激光雷达，其体积较小、功耗较低，能够适应更多场景的需求。固态激光雷达目前也逐渐被自动驾驶系统所采用，并在一些场景中取代了传统的旋转式激光雷达。

## 海上小目标雷达

在海上测量小目标，需要选择具有较高分辨率和探测灵敏度的雷达，常用的选择包括以下几种：

1. X波段雷达：X波段雷达工作频率在8-12 GHz之间，具有较高的分辨率和较小的波长，可以用于探测小目标，例如小型船只和浮标等。X波段雷达在海上应用广泛，可以实现较高精度的目标探测和跟踪。
2. Ku波段雷达：Ku波段雷达工作频率在12-18 GHz之间，与X波段雷达相比，具有更高的分辨率和较小的波长。Ku波段雷达通常用于探测小型船只、浮标、救生筏等小目标，可以实现高精度的目标识别和跟踪。
3. S波段雷达：S波段雷达工作频率在2-4 GHz之间，波长较长，但具有较高的穿透能力和较大的测量范围。S波段雷达通常用于探测大型船只和岸边建筑物等目标，但也可以用于探测小目标。

常见雷达类型

Welcome to my tech blog! Here, I document my coding journey and explore various technologies, focusing on practical solutions and streamlined techniques. From programming insights to tool recommendations, I share hands-on experiences that help sharpen your skills. Let’s learn and grow together!