STM32的串口通信UART/TTL

最新推荐文章于 2025-11-08 02:34:20 发布
原创 最新推荐文章于 2025-11-08 02:34:20 发布 · 3.5k 阅读 · 20 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #post #stm32 #串口通信 #http

本文详细介绍了STM32的串口配置，包括STM32F103C8T6和STM32F401CCU6的串口分配，并讲解了串口中断模式，如TXE、RXNE、TC等中断源和待处理位。还讨论了串口通信编程中的常见问题，如缓冲区溢出、非请求响应和响应等待时间，提出了解决方案。最后，展示了如何实现串口发送和接收的消息处理函数。

常用的串口pin

STM32的串口是基础通信方式, 每个型号都带多组串口, 一般都使用默认的组, 可以参考芯片的datasheet, 去看pinout and pin definitions,

stm32f103c8t6

这是48pin的芯片, 提供3组串口, 注意USART1是APB2, USART2和3都是PBA1. 各组串口的pin脚为

USART2USART1USART3
总线APB1APB2APB1
TXPA2PA9PB10
RXPA3PA10PB11
CTSPA0PA11PB13
RTSPA1PA12PB14
CKPA4PA8PB12

可以同时使用三组UART: USART1(PA9, PA10), USART2(PA2, PA3), USART3(PB10, PB11)

stm32f401ccu6

USART1和USART6是APB2, USART2是APB1

USART2USART1USART6
总线APB1APB2APB2
TXPA2PA9 / PB6PA11
RXPA3PA10 / PB7PA12
CTSPA0PA11PB13
RTSPA1PA12PB14
CKPA4PA8PC8

可以同时使用三组UART: USART1(PA9, PA10)或(PB6, PB7), USART2(PA2, PA3), USART6(PA11, PA12)

串口相关的中断

Interrupt Mode
  ===============
  In Interrupt Mode, the USART communication can be managed by 8 interrupt sources and 10 pending bits: 

  Pending Bits:
  ------------- 
     1. USART_IT_TXE :  to indicate the status of the transmit buffer register
     2. USART_IT_RXNE : to indicate the status of the receive buffer register
     3. USART_IT_TC :   to indicate the status of the transmit operation
     4. USART_IT_IDLE : to indicate the status of the Idle Line
     5. USART_IT_CTS :  to indicate the status of the nCTS input
     6. USART_IT_LBD :  to indicate the status of the LIN break detection
     7. USART_IT_NE :   to indicate if a noise error occur
     8. USART_IT_FE :   to indicate if a frame error occur
     9. USART_IT_PE :   to indicate if a parity error occur
    10. USART_IT_ORE :  to indicate if an Overrun error occur

  Interrupt Source:
  -----------------
     1. USART_IT_TXE :  specifies the interrupt source for the Tx buffer empty interrupt. 
     2. USART_IT_RXNE : specifies the interrupt source for the Rx buffer not empty interrupt.
     3. USART_IT_TC :   specifies the interrupt source for the Transmit complete interrupt. 
     4. USART_IT_IDLE : specifies the interrupt source for the Idle Line interrupt.             
     5. USART_IT_CTS :  specifies the interrupt source for the CTS interrupt. 
     6. USART_IT_LBD :  specifies the interrupt source for the LIN break detection interrupt. 
     7. USART_IT_PE :   specifies the interrupt source for the parity error interrupt. 
     8. USART_IT_ERR :  specifies the interrupt source for the errors interrupt.

@note Some parameters are coded in order to use them as interrupt source or as pending bits.

  In this Mode it is advised to use the following functions:
     - void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);
     - ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);
     - void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT);

pending bits是一种防止中断丢失的机制, 当Mask bits为1的时候中断请求并不会发出, 而是将pending bits置为1, 当mask bits变为0时中断会发出, 然后pending位被清0.

串口通信编程

串口通信就是TX发送和RX接收. 其中TX在绝大多数场合可以直接按字节发送, 需要额外处理的是RX.

串口通信的常见问题

理想的通信方式是发送->等待响应->返回响应, TX之后等待RX响应, 而且响应是完整发送的, 但是实际使用中, RX接收有多种特殊情况

响应太长将缓冲区写满

缓冲区一般会设置为u8[128], 或者u8[256], 对于大部分消息是够的, 对于更大的返回, 如果会造成缓冲溢出的, 建议

  1. 如果是累计的多个返回, 最好改进接收响应完成状态的判断机制, 尽量分段处理
  2. 对于无法分段的特殊情况, 需要保留最新的内容, 将缓冲设计成FIFO的环形结构, 后接收的消息可以覆盖掉最早的内容.

非请求产生的响应

有两种情况, 一种是在设备开机阶段自检和初始化产生的内容, 这些内容可以通过在上位机设置足够长的delay, 把这些内容忽略掉; 第二种就是在正常工作中, 随时出现的通知信息, 这种情况就不能使用发送->等待的处理方式了, 因为RX和TX完全异步. 体现在代码中, 就是TX之后不等待RX的结果. 在TX之后只需要必要的delay, 例如20ms, 以避免和下一条TX连在一起.

在处理接收时, 可以使用IDLE中断, 也可以使用定时器判断.

  • 如果每次响应到达时基本都是完整的(中间的间隔不会超过1个字节的传输耗时), 就可以使用IDLE中断, 这样实现最简单
  • 如果不能满足上一条的条件, 使用IDLE中断就会有问题, 一个响应可能会被拆成好几份, 导致后期处理难度增大. 这时候可以用一个单独的定时器做延时, 判断响应是否接收完整. 延时设置到10ms - 40ms, 对于大部分串口设备的返回都可以完整收集, 又不至于累积太长的响应. 在定时器中断时将缓冲中的整个响应取出处理.

因请求产生的响应, 响应等待时间可能较长(几十毫秒到几百毫秒)

首先, 如果串口设备带回显, 要将回显先关闭. 回显是为了方便手工调试, 但是在程序中, 会引起不必要的麻烦. 因为命令通过TX输出之后RX就会立即收到回显, 但是真正的响应要过一阵子回来, 在程序处理中很可能就把回显当成是响应, 而把真正的响应丢了. 虽然可以将等待响应的定时器设置得长一点, 但是中间的空档期长, 出错的概率也越大. 对响应的接收是通过RXNE中断将接收到的字节写入缓冲实现的, 和前面的处理方式一样, 可以通过定时器延时, 在请求发送后, 设置一个超时时间然后阻塞进程, 在进程中循环判断响应的接收情况. 在串口的中断处理中, 每次收到RXNE中断后都重置并启用定时器延时20ms, 直至超过这个间隔无响应, 在定时器中断中将响应完整状态置位, 在进程中收集到响应.

串口通信常见实现方式

一般通过以下的步骤实现串口通信

1. 实现Buffer工具方法

#ifndef __BUFFER_H_
#define __BUFFER_H_

#include "stm32f10x.h"

typedef struct
{
  u8* buf;
  u16 size;
  u16 front;
  u16 rear;
} BufferTypeDef;

typedef struct
{
  u8 size;
  u8 length;
  u8* data;
} BufferClip;

void Buffer_Reset(BufferTypeDef* buff);
u16  Buffer_Length(BufferTypeDef* buff);
u8   Buffer_Push(BufferTypeDef* buff, u8 data);
u8   Buffer_Pop(BufferTypeDef* buff, u8* data);
u8   Buffer_Pop_All(BufferTypeDef* buff, BufferClip* clip);
void Buffer_Print(BufferTypeDef* buff);
void Buffer_Print_Hex(BufferTypeDef* buff);
void Buffer_Print_All(BufferTypeDef* buff);

void Buffer_Clip_Print(BufferClip* clip);
void Buffer_Clip_Print_Hex(BufferClip* clip);

#endif




#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "buffer.h"

void Buffer_Reset(BufferTypeDef* buff)
{
  buff->front = 0;
  buff->rear = 0;
}

u16 Buffer_Length(BufferTypeDef* buff)
{
  if (buff->rear >= buff->front) {
    return buff->rear - buff->front;
  } else {
    return (buff->size - buff->front) + (buff->rear - 0);
  }
}

u8 Buffer_Push(BufferTypeDef* buff, u8 data)
{
  buff->buf[buff->rear] = data;
  buff->rear++;
  if (buff->rear >= buff->size) {
    buff->rear = 0;
  }
  if (buff->front == buff->rear) {
    buff->front = (buff->front + 1) % buff->size;
    return NULL;
  } else {
    return !NULL;
  }
}

u8 Buffer_Pop(BufferTypeDef* buff, u8* data)
{
  if (buff->front == buff->rear) return NULL;

  *data = buff->buf[buff->front];
  buff->front = (buff->front + 1) % buff->size;
  return !NULL;
}

u8 Buffer_Pop_All(BufferTypeDef* buff, BufferClip* clip)
{
  if (buff->front == buff->rear) return NULL;
  
  memset(clip->data, 0x00, clip->size * sizeof(u8));
  clip->length = 0;
  if (buff->front > buff->rear) {
    while (buff->front < buff->size && clip->length <= clip->size) {
      *(clip->data + clip->length++) = buff->buf[buff->front++];
    }
    if (buff->front == buff->size) {
      buff->front = 0;
    }
  }
  while (buff->front < buff->rear && clip->length <= clip->size) {
    *(clip->data + clip->length++) = buff->buf[buff->front++];
  }
  return !NULL;
}

void Buffer_Print(BufferTypeDef* buff)
{
  printf("BUFF:[%03d,%03d)",buff->front, buff->rear);
  if (buff->front == buff->rear) {
    // print nothing;
  } else if (buff->front < buff->rear) {
    for(int i=buff->front; i < buff->rear; i++) {
      printf("%c", buff->buf[i]);
    }
  } else {
    for(int i = buff->front; i < buff->size; i++) {
      printf("%c", buff->buf[i]);
    }
    for(int i = 0; i < buff->rear; i++) {
      printf("%c", buff->buf[i]);
    }
  }
  printf("\r\n");
}

void Buffer_Print_Hex(BufferTypeDef* buff)
{
  printf("BUFF:[%03d,%03d)",buff->front, buff->rear);
  if (buff->front == buff->rear) {
    // print nothing;
  } else if (buff->front < buff->rear) {
    for(int i=buff->front; i<buff->rear; i++) {
      printf("%02X ", buff->buf[i]);
    }
  } else {
    for(int i=buff->front; i < buff->size; i++) {
      printf("%02X ", buff->buf[i]);
    }
    for(int i=0; i<buff->rear; i++) {
      printf("%02X ", buff->buf[i]);
    }
  }
  printf("\r\n");
}

void Buffer_Print_All(BufferTypeDef* buff)
{
  printf("BUFF:[%d,%d)",buff->front, buff->rear);
  for(int i=0; i < buff->size; i++) {
    printf("%c", buff->buf[i]);
  }
  printf("\r\n");
}

void Buffer_Clip_Print(BufferClip* clip)
{
  printf("CLIP:[%03d]", clip->length);
  for(int i = 0; i < clip->length; i++) {
    printf("%c", clip->data[i]);
  }
  printf("\r\n");
}

void Buffer_Clip_Print_Hex(BufferClip* clip)
{
  printf("CLIP:[%03d]", clip->length);
  for(int i = 0; i < clip->length; i++) {
    printf("%02X ", clip->data[i]);
  }
  printf("\r\n");
}

2. 初始化UART端口: 使能GPIO, UART, NVIC

BufferTypeDef RFID_RX_BUF;
u8 RFID_RX_BUF_BUFF[RFID_BUF_SIZE] = {0x00};

BufferClip RFID_RX_CLIP;
u8 RFID_RX_CLIP_DATA[UINT8_MAX] = {0x00};

u8 RFID_RX_STATE = 0;

void RFID_Init(void)
{
  RFID_RX_BUF.buf = RFID_RX_BUF_BUFF;
  RFID_RX_BUF.size = RFID_BUF_SIZE;
  RFID_RX_CLIP.data = RFID_RX_CLIP_DATA;
  RFID_RX_CLIP.size = UINT8_MAX;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  RCC_APB1PeriphClockCmd(RFID_RCC, ENABLE);
  // GPIO for TX
  GPIO_InitTypeDef  GPIO_InitStructure;
  GPIO_InitStructure.GPIO_Pin = RFID_TX_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(RFID_TX_GPIO, &GPIO_InitStructure);
  // GPIO for RX
  GPIO_InitStructure.GPIO_Pin = RFID_RX_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(RFID_RX_GPIO, &GPIO_InitStructure); 
  // NVIC
  NVIC_InitTypeDef NVIC_InitStructure;
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
  NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority =1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  // USART
  USART_DeInit(RFID_USART);
  USART_InitTypeDef USART_InitStructure;
  USART_InitStructure.USART_BaudRate = 115200;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No;
  USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_Init(RFID_USART, &USART_InitStructure);
  USART_ClearFlag(RFID_USART, USART_FLAG_CTS);
  USART_Cmd(RFID_USART, ENABLE);

  USART_ITConfig(RFID_USART, USART_IT_RXNE, ENABLE);
  printf("## RFID Initialized ##\r\n");
}

3. 实现中断处理方法接收消息

一个是串口的RXNE中断, 用于接收每个字节; 另一个是TIMx的计时中断, 用于标记响应接收完成

void USART3_IRQHandler(void)
{
  u8 rev_byte;
  u32 clear;
  if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  {
    rev_byte = USART_ReceiveData(USART3);
    Buffer_Push(&RFID_RX_BUF, rev_byte);
    // Reset the TIM2 counter and enable it
    TIM_SetCounter(TIM2, 0);
    TIM_Cmd(TIM2, ENABLE);
    USART_ClearITPendingBit(USART3, USART_IT_RXNE);
  }
}

void TIM2_IRQHandler(void)
{
  if(TIM_GetITStatus(TIM2, TIM_IT_Update) == SET) {
    printf("RFID_RX_STATE++\r\n");
    RFID_RX_STATE++;
  }
  TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  TIM_Cmd(TIM2, DISABLE);
}

4. 实现消息发送

下面这个例子, 在收到消息后, 调用 RFID_Handle_Message()处理响应

void RFID_Send_String(const u8* data, u16 length)
{
  printf("RFID CMD: ");
  for (u16 i = 0; i < length; i++) {
    printf("%02X ", *(data + i));
    USART_SendData(RFID_USART, *(data + i));
    while(USART_GetFlagStatus(RFID_USART, USART_FLAG_TXE) == RESET) { // Wait till sent
      ;// Do nothing
    }
  }
  printf(">> Sent\r\n");
}

bool RFID_Send_Cmd(const u8* cmd, u16 length)
{
  RFID_Send_String(cmd, length);
  // Delay 50ms to avoid being joinned by other commands
  Systick_Delay_ms(50);

  u8 waittime = 10;
  while (waittime--) {
    if(RFID_RX_STATE > 0) {
      printf("RFID_RX_STATE %d\r\n", RFID_RX_STATE);
      if (Buffer_Pop_All(&RFID_RX_BUF, &RFID_RX_CLIP) != NULL) {
        Buffer_Clip_Print_Hex(&RFID_RX_CLIP);
        RFID_Handle_Message();
      }
      RFID_RX_STATE--;
    }
    Systick_Delay_ms(50);
  }
  return true;
}

下面这个例子, 直接在参数中指定期望的响应结果, 只需要返回对比的结果

u8 ESP8266_Send_Cmd2(char *cmd, char *ack, char *ack2, u16 waittime)
{
  ESP8266_Send_String((u8 *)cmd);
  Systick_Delay_ms(50);
  // Make sure waittime is set
  if (waittime < 10) waittime = 10;

  while (waittime--) {
    if(ESP_RX_STATE > 0) {
      printf("ESP_RX_STATE %d\r\n", ESP_RX_STATE);
      ESP_RX_STATE--;
      if (Buffer_Pop_All(&ESP_RX_BUF, &ESP_RX_CLIP) != NULL) {
        Buffer_Clip_Print(&ESP_RX_CLIP);
        if(strstr((char *)(ESP_RX_CLIP.data), ack) != NULL) {
          printf("return success\r\n\n");
          return ACK_SUCCESS;
        }
        if (strlen(ack2) > 0) {
          if(strstr((char *)(ESP_RX_CLIP.data), ack2) != NULL) {
            printf("return success\r\n\n");
            return ACK_SUCCESS;
          }
        }
      }
    }
    Systick_Delay_ms(20);
  }
  printf("return defeat\r\n\n");
  return ACK_DEFEAT;
}

参考

STM32：TTL串口调试
superSmart_Dong的博客
10-24 5184
TTL只需要两个线就可以完成两个设备之间的双向通信，一个发送电平的I/O称之为TX，与另一个设备的接收I/O口RX相互连接。两设备之间还需要连接地线(GND)，这样两设备就有相同的0V参考电势。
STM32基础之库函数串口的使用（串口1）
m0_58832575的博客
04-12 3718
STM32串口
学习单片机：stm32单片机之TTL串口通信
最新发布
xgjtfn的博客
11-08 983
不能写在while里，我们写在回调的函数末尾。串口接收函数，参数1.要操作的串口的指针，参数2.要发送的信息的指针，参数3.发送内容的长度（可使用strlen（）函数），参数4.超时时间（多长时间后若没有发送就停止发送），HAL_MAX_DELAY代表不设置超时时间。串口发送函数，参数1.要操作的串口的指针，参数2.要发送的信息的指针，参数3.发送内容的长度（可使用strlen（）函数），参数4.超时时间（多长时间后若没有发送就停止发送），HAL_MAX_DELAY代表不设置超时时间。
《嵌入式系统》知识总结11：STM32串口
qq_53914247的博客
06-05 2716
• 并行：使用8根数据线一次传送一个字节（或使用16根数据线一次传送2个字节，...）• 串行：使用少量数据信号线（8根以下），将数据逐位分时传送• 并行vs串行：类似于多车道vs单车道。
【STM32】串口通信基本原理（超基础、详细版）
u013407012的专栏
10-09 7991
本文链接：https://blog.youkuaiyun.com/qq_38410730/article/details/79887200 STM32F1xx官方资料： 《STM32中文参考手册V10》-第25章通用同步异步收发器（USART) 通信接口背景知识 设备之间通信的方式 一般情况下，设备之间的通信方式可以分成并行通信和串行通信两种。它们的区别是： 并、串行通信的区别 并行通...
stm32串口通信程序之UART2(TTL)
luoyir1997的博客
05-18 1万+
一、硬件连接
stm32f407UART4串口4标准例程
01-03
UART4是STM32F407中的一个串行通信端口，用于设备间的异步数据传输。在实际应用中，如传感器数据采集、模块间通信或者调试输出等场景，UART4都能发挥重要作用。 本例程的核心在于如何配置和使用STM32F407的UART4...
【stm32f4】UART串口通信(stm32hal库)
2301_77699699的博客
04-04 1162
UART（Universal Asynchronous Receiver/Transmitter）即通用异步收发器，是一种常用的串行通信协议，在微控制器、嵌入式系统以及各种电子设备中应用广泛。 UART是一种串行、异步、全双工的通信协议。串行意味着数据是一位一位顺序传输；异步表示通信双方不需要共享同一个时钟信号，每个设备有自己独立的时钟；全双工则允许两个设备在同一时间进行双向的数据传输。 UART硬件电路相对简单，双向传输数据一般有两根通信线，即发送端TX和接收端RX，主机和从
电脑之间USB/TTL串口通信与基于STM32CubeMXHAL库的USART中断STM32串口通信
m0_74172414的博客
12-06 1066
本次实验涵盖了电脑之间通过USB/TTL串口通信以及基于STM32CubeMX HAL库的USART中断实现STM32串口通信两部分内容。在电脑之间的USB/TTL串口通信中，利用相应的串口线连接电脑，借助特定的串口调试助手等工具，实现数据在不同电脑间的传输交互，能直观感受串口通信的基本原理与过程。
STM32——串口（UART）使用
m0_56399733的博客
01-02 9853
节主要学习了STM32串口的相关知识，包括有：基本的通信方式，串口通信的基本概念，相关寄存器的设置，以及如何利用HAL进行配置，最后还实现了一个简单的实现。
详解STM32串口通信基本原理
优快云83的博客
08-30 892
这里的交叉连接的意思就是，芯片1的RxD连接芯片2的TXD，芯片2的RXD连接芯片1的TXD。所以单片机串口与PC串口通信就应该遵循下面的连接方式：在单片机串口与上位机给出的RS232口之间，通过电平转换电路(如下面图中的Max232芯片) 实现TTL电平与RS232电平之间的转换。在同步通讯中，数据信号所传输的内容绝大部分是有效数据，而异步通讯中会则会包含数据帧的各种标识符，所以同步通讯效率高，但是同步通讯双方的时钟允许误差小，稍稍时钟出错就可能导致数据错乱，异步通讯双方的时钟允许误差较大。
STM32F103C8T6同时打开串口1&2&3.zip
07-21
STM32F103C8T6同时使用串口1，串口2，串口3，程序下载下来直接可用，亲测可用，使用8M晶振
串口调试工具 TTL
12-22
TTL调试必备工具，非常强大
stm32串口控制台+LCD回显
09-24
stm32 串口控制台源代码，串口回显+LCD回显 支持函数添加指令。指令可携带4个参数，可用于硬件控制及参数查看。
STM32按键中断+串口回显
12-04
一个STM32的按键中断控制及串口通信程序，适合初学者的例程。
STM32F103C8T6的串口1和串口3收发实验
11-30
串口1、3接收有后缀"\r\n"和无后缀"\r\n"的不定长数据（不得超过固定长度） 串口1通过重定义printf打印接收到串口1和串口3的数据，当接收到指定字符串则通过串口3发送指定字符串
【STM32】入门（五）：串口TTL、RS232、RS485
郭老二
08-04 5121
TTL ：全双工 ，逻辑0对应0V，逻辑1对应3.3V或者5V，一般从单片机引脚直接引出，电平3.3或5V是与IO电平兼容；RS232：全双工，逻辑0对应+3V至+15V，逻辑1对应-15V至-3V ，TTL经过电平转换芯片后可以输出RS232。RS485：半双工，逻辑0对应-6V至-2V，逻辑1对应+2V至+6V，这里的电平指AB两线间的电压差，即差分方式传输，因此可以长距离传输。.........
STM32常见通信方式（TTL、RS232、RS485、I2C，SPI，CAN）总结
热门推荐
位文杰的博客
06-05 5万+
STM32常见通信方式（TTL、RS232、RS485、I2C，SPI,CAN）总结 一、TTL电平：全双工（逻辑1: 2.4V–5V 逻辑0: 0V–0.5V） 1、硬件框图如下，TTL用于两个MCU间通信 2、‘0’和‘1’表示 二、RS-232电平：全双工（逻辑1：-15V–5V 逻辑0：+3V–+15V） 1、硬件框图如下，...
STM32串口通信配置（USART1+USART2+USART3+UART4）
yugang_123456的博客
03-05 2492
一、串口一的配置（初始化+中断配置+中断接收函数） 1 /*=============================================================================== 2 Copyright: 3 Version: 4 Author: 5 Date: 2017/11/3 6 Description: 7...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值