使用dht20在stm32实现温湿度检测

已于 2023-11-16 20:02:44 修改
阅读量1.4k 收藏 14
点赞数 1
文章标签： stm32 单片机 嵌入式硬件
于 2023-11-13 18:44:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29618735/article/details/134376049
版权

dht20硬件和环境i2c

I2C（Inter-Integrated Circuit）是一种串行通信协议，用于在电子设备之间进行通信。它由两条线路组成：时钟线（SCL，Serial Clock）和数据线（SDA，Serial Data）。I2C协议使用主从结构，其中一个设备充当主设备，负责发起和控制通信，其他设备则作为从设备响应主设备的命令。

在I2C通信中，主设备生成时钟信号来同步通信过程，并通过数据线发送和接收数据。主设备发起通信后，选择要与之通信的从设备地址，并向其发送命令或数据。从设备在接收到命令后执行相应的操作，并将结果返回给主设备。这种通信方式适用于短距离的连接，常用于连接微控制器、传感器、存储器和其他外围设备。

dht20和aht20没什么区别，都是奥森的产品，自己挑选就可以。

将AHT20传感器的SCL引脚连接到STM32的I2C时钟线引脚（通常标记为SCL、SCK或I2C_SCL），将SDA引脚连接到STM32的I2C数据线引脚（通常标记为SDA、SDI或I2C_SDA）。还有vcc和grund 自己对应接上
在这里插入图片描述
这是奥森官网的指导手册。
我们这SDA和SCL使用的是PB7和PB6自己对应接上就行。
在传感器读取到对应数据过后我们还有使用DMA通信到pc机上。
在循环里面不断发送我们的温湿度，如果有也可以设定中断服务函数，实现其他功能。还有处理i2c的通信初始化。

我们使用keil 5进行操作。stm32f103c8t6最小开发板。

首先创建一个包含常规stm32固件库的工程，方便环境配置。
然后进行编写。
main.c

#include "Delay.h"
#include "usart.h"
#include "bsp_i2c.h"


int main(void)
{	
	    
	uart_init(115200);	
	IIC_Init();
		while(1)
	{
		printf("开始测试温湿度");
		read_AHT20_once();
		delay_ms(1500);
  }
}

下一个是usart.c

#include "sys.h"
#include "usart.h"






#if SYSTEM_SUPPORT_UCOS
#include "includes.h"					
#endif

  
#if 1
#pragma import(__use_no_semihosting)             
            
struct __FILE 
{ 
	int handle; 

}; 

FILE __stdout;       
  
void _sys_exit(int x) 
{ 
	x = x; 
} 

int fputc(int ch, FILE *f)
{      
	while((USART1->SR&0X40)==0); 
    USART1->DR = (u8) ch;      
	return ch;
}
#endif 


 
#if EN_USART1_RX   
	
u8 USART_RX_BUF[USART_REC_LEN];    

u16 USART_RX_STA=0;        
  
void uart_init(u32 bound){
  
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	
   
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	
    GPIO_Init(GPIOA, &GPIO_InitStructure);
   
    //USART1_RX	  PA.10
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);  

   //Usart1 NVIC 

    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			
	NVIC_Init(&NVIC_InitStructure);	
  
   //USAR

	USART_InitStructure.USART_BaudRate = bound;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	

    USART_Init(USART1, &USART_InitStructure); 
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    USART_Cmd(USART1, ENABLE);                    

}



void USART1_IRQHandler(void)                
	{
	u8 Res;
#ifdef OS_TICKS_PER_SEC	 	
	OSIntEnter();    
#endif
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  
		{
		Res =USART_ReceiveData(USART1);//(USART1->DR);	
		
		if((USART_RX_STA&0x8000)==0)
			{
			if(USART_RX_STA&0x4000)
				{
				if(Res!=0x0a)USART_RX_STA=0;
				else USART_RX_STA|=0x8000;	
				}
			else 
				{	
				if(Res==0x0d)USART_RX_STA|=0x4000;
				else
					{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;  
					}		 
				}
			}   		 
     } 
#ifdef OS_TICKS_PER_SEC	 	
	OSIntExit();  											 
#endif
} 
#endif

下一个是usart.h

#ifndef __USART_H
#define __USART_H
#include "stdio.h"	
#include "sys.h" 




#define USART_REC_LEN  			200  	
#define EN_USART1_RX 			1		   
	  	
extern u8  USART_RX_BUF[USART_REC_LEN];  
extern u16 USART_RX_STA;         		

void uart_init(u32 bound);
#endif

下一个bsp_i2c.c

#include "bsp_i2c.h"
#include "delay.h"

uint8_t   ack_status=0;
uint8_t   readByte[6];
uint8_t   AHT20_status=0;

uint32_t  H1=0;  //Humility
uint32_t  T1=0;  //Temperature

uint8_t  AHT20_OutData[4];
uint8_t  AHT20sendOutData[10] = {0xFA, 0x06, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};

void IIC_Init(void)
{					     
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
	   
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;  
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
 
	IIC_SCL=1;
	IIC_SDA=1;
 
}

void IIC_Start(void)
{
	SDA_OUT();     
	IIC_SDA=1;	  	  
	IIC_SCL=1;
	delay_us(4);
 	IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
	delay_us(4);
	IIC_SCL=0;
}	  

void IIC_Stop(void)
{
	SDA_OUT();
	IIC_SCL=0;
	IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
 	delay_us(4);
	IIC_SCL=1; 
	IIC_SDA=1;
	delay_us(4);							   	
}

u8 IIC_Wait_Ack(void)
{
	u8 ucErrTime=0;
	SDA_IN();     
	IIC_SDA=1;delay_us(1);	   
	IIC_SCL=1;delay_us(1);	 
	while(READ_SDA)
	{
		ucErrTime++;
		if(ucErrTime>250)
		{
			IIC_Stop();
			return 1;
		}
	}
	IIC_SCL=0;	   
	return 0;  
} 

void IIC_Ack(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=0;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}
	    
void IIC_NAck(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=1;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}					 				     
		  
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
		SDA_OUT(); 	    
    IIC_SCL=0;
    for(t=0;t<8;t++)
    {              
        IIC_SDA=(txd&0x80)>>7;
        txd<<=1; 	  
		delay_us(2);  
		IIC_SCL=1;
		delay_us(2); 
		IIC_SCL=0;	
		delay_us(2);
    }	 
} 	    

u8 IIC_Read_Byte(unsigned char ack)
{
	unsigned char i,receive=0;
	SDA_IN();
  for(i=0;i<8;i++ )
	{
    IIC_SCL=0; 
    delay_us(2);
		IIC_SCL=1;
    receive<<=1;
    if(READ_SDA)receive++;   
		delay_us(1); 
  }					 
	if (!ack)
			IIC_NAck();
	else
			IIC_Ack();  
	return receive;
}
 
void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
{
	IIC_Start();  
	
	if(device_addr==0xA0) 
		IIC_Send_Byte(0xA0 + ((addr/256)<<1));
	else
		IIC_Send_Byte(device_addr);	  
	IIC_Wait_Ack(); 
	IIC_Send_Byte(addr&0xFF); 
	IIC_Wait_Ack(); 
	IIC_Send_Byte(data);   							   
	IIC_Wait_Ack();  		    	   
  IIC_Stop();
	if(device_addr==0xA0) 
		delay_ms(10);
	else
		delay_us(2);
}
 
uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead) 
{	
		uint16_t data;
		IIC_Start();  
		if(device_addr==0xA0)
			IIC_Send_Byte(0xA0 + ((addr/256)<<1));
		else
			IIC_Send_Byte(device_addr);	
		IIC_Wait_Ack();
		IIC_Send_Byte(addr&0xFF);   
		IIC_Wait_Ack(); 
 
		IIC_Start();  	
		IIC_Send_Byte(device_addr+1);	  
		IIC_Wait_Ack();
		if(ByteNumToRead == 1)
		{
			data=IIC_Read_Byte(0);
		}
		else
			{
				data=IIC_Read_Byte(1);
				data=(data<<8)+IIC_Read_Byte(0);
			}
		IIC_Stop();   
		return data;
}



void  read_AHT20_once(void)
{
	delay_ms(10);

	reset_AHT20();
	delay_ms(10);

	init_AHT20();
	delay_ms(10);

	startMeasure_AHT20();
	delay_ms(80);

	read_AHT20();
	delay_ms(5);
}


void  reset_AHT20(void)
{

	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status) printf("1");
	else printf("1-n-");
	I2C_WriteByte(0xBA);
	ack_status = Receive_ACK();
		if(ack_status) printf("2");
	else printf("2-n-");
	I2C_Stop();

	/*
	AHT20_OutData[0] = 0;
	AHT20_OutData[1] = 0;
	AHT20_OutData[2] = 0;
	AHT20_OutData[3] = 0;
	*/
}



void  init_AHT20(void)
{
	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status) printf("3");
	else printf("3-n-");	
	I2C_WriteByte(0xE1);
	ack_status = Receive_ACK();
	if(ack_status) printf("4");
	else printf("4-n-");
	I2C_WriteByte(0x08);
	ack_status = Receive_ACK();
	if(ack_status) printf("5");
	else printf("5-n-");
	I2C_WriteByte(0x00);
	ack_status = Receive_ACK();
	if(ack_status) printf("6");
	else printf("6-n-");
	I2C_Stop();
}



void  startMeasure_AHT20(void)
{
	//------------
	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status) printf("7");
	else printf("7-n-");
	I2C_WriteByte(0xAC);
	ack_status = Receive_ACK();
	if(ack_status) printf("8");
	else printf("8-n-");
	I2C_WriteByte(0x33);
	ack_status = Receive_ACK();
	if(ack_status) printf("9");
	else printf("9-n-");
	I2C_WriteByte(0x00);
	ack_status = Receive_ACK();
	if(ack_status) printf("10");
	else printf("10-n-");
	I2C_Stop();
}



void read_AHT20(void)
{
	uint8_t   i;

	for(i=0; i<6; i++)
	{
		readByte[i]=0;
	}

	//-------------
	I2C_Start();

	I2C_WriteByte(0x71);
	ack_status = Receive_ACK();
	readByte[0]= I2C_ReadByte();
	Send_ACK();

	readByte[1]= I2C_ReadByte();
	Send_ACK();

	readByte[2]= I2C_ReadByte();
	Send_ACK();

	readByte[3]= I2C_ReadByte();
	Send_ACK();

	readByte[4]= I2C_ReadByte();
	Send_ACK();

	readByte[5]= I2C_ReadByte();
	SendNot_Ack();
	//Send_ACK();

	I2C_Stop();

	//--------------
	if( (readByte[0] & 0x68) == 0x08 )
	{
		H1 = readByte[1];
		H1 = (H1<<8) | readByte[2];
		H1 = (H1<<8) | readByte[3];
		H1 = H1>>4;

		H1 = (H1*1000)/1024/1024;

		T1 = readByte[3];
		T1 = T1 & 0x0000000F;
		T1 = (T1<<8) | readByte[4];
		T1 = (T1<<8) | readByte[5];

		T1 = (T1*2000)/1024/1024 - 500;

		AHT20_OutData[0] = (H1>>8) & 0x000000FF;
		AHT20_OutData[1] = H1 & 0x000000FF;

		AHT20_OutData[2] = (T1>>8) & 0x000000FF;
		AHT20_OutData[3] = T1 & 0x000000FF;
	}
	else
	{
		AHT20_OutData[0] = 0xFF;
		AHT20_OutData[1] = 0xFF;

		AHT20_OutData[2] = 0xFF;
		AHT20_OutData[3] = 0xFF;
		printf("꧰üá?");

	}
	printf("\r\n");
	printf("温度:%d%d.%d",T1/100,(T1/10)%10,T1%10);
	printf("湿度:%d%d.%d",H1/100,(H1/10)%10,H1%10);
	printf("\r\n");
}




uint8_t  Receive_ACK(void)
{
	uint8_t result=0;
	uint8_t cnt=0;

	IIC_SCL = 0;
	SDA_IN(); 
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);

	while(READ_SDA && (cnt<100))
	{
		cnt++;
	}

	IIC_SCL = 0;
	delay_us(4);

	if(cnt<100)
	{
		result=1;
	}
	return result;
}



void  Send_ACK(void)
{
	SDA_OUT();
	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 0;
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);
	IIC_SCL = 0;
	delay_us(4);

	SDA_IN();
}



void  SendNot_Ack(void)
{
	SDA_OUT();
	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 1;
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);

	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 0;
	delay_us(4);
}


void I2C_WriteByte(uint8_t  input)
{
	uint8_t  i;
	SDA_OUT();
	for(i=0; i<8; i++)
	{
		IIC_SCL = 0;
		delay_ms(5);

		if(input & 0x80)
		{
			IIC_SDA = 1;
			//delaymm(10);
		}
		else
		{
			IIC_SDA = 0;
			//delaymm(10);
		}

		IIC_SCL = 1;
		delay_ms(5);

		input = (input<<1);
	}

	IIC_SCL = 0;
	delay_us(4);

	SDA_IN();
	delay_us(4);
}	


uint8_t I2C_ReadByte(void)
{
	uint8_t  resultByte=0;
	uint8_t  i=0, a=0;

	IIC_SCL = 0;
	SDA_IN();
	delay_ms(4);

	for(i=0; i<8; i++)
	{
		IIC_SCL = 1;
		delay_ms(3);

		a=0;
		if(READ_SDA)
		{
			a=1;
		}
		else
		{
			a=0;
		}

		//resultByte = resultByte | a;
		resultByte = (resultByte << 1) | a;

		IIC_SCL = 0;
		delay_ms(3);
	}

	SDA_IN();
	delay_ms(10);

	return   resultByte;
}


void  set_AHT20sendOutData(void)
{
	/* --------------------------
	 * 0xFA 0x06 0x0A temperature(2 Bytes) humility(2Bytes) short Address(2 Bytes)
	 * And Check (1 byte)
	 * -------------------------*/
	AHT20sendOutData[3] = AHT20_OutData[0];
	AHT20sendOutData[4] = AHT20_OutData[1];
	AHT20sendOutData[5] = AHT20_OutData[2];
	AHT20sendOutData[6] = AHT20_OutData[3];

//	AHT20sendOutData[7] = (drf1609.shortAddress >> 8) & 0x00FF;
//	AHT20sendOutData[8] = drf1609.shortAddress  & 0x00FF;

//	AHT20sendOutData[9] = getXY(AHT20sendOutData,10);
}


void  I2C_Start(void)
{
	SDA_OUT();
	IIC_SCL = 1;
	delay_ms(4);

	IIC_SDA = 1;
	delay_ms(4);
	IIC_SDA = 0;
	delay_ms(4);

	IIC_SCL = 0;
	delay_ms(4);
}



void  I2C_Stop(void)
{
	SDA_OUT();
	IIC_SDA = 0;
	delay_ms(4);

	IIC_SCL = 1;
	delay_ms(4);

	IIC_SDA = 1;
	delay_ms(4);
}

下一个bsp_i2c.h

#ifndef __BSP_I2C_H
#define __BSP_I2C_H

#include "sys.h"
#include "delay.h"
#include "usart.h"
//  PB6,PB7
 
#define SDA_IN()  {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
#define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}
 
//IO2ù×÷oˉêy	 
#define IIC_SCL    PBout(6) //SCL
#define IIC_SDA    PBout(7) //SDA	 
#define READ_SDA   PBin(7)  


//IIC?ùóD2ù×÷oˉêy
void IIC_Init(void);              		 
void IIC_Start(void);				
void IIC_Stop(void);	  		
void IIC_Send_Byte(u8 txd);			
u8 IIC_Read_Byte(unsigned char ack);
u8 IIC_Wait_Ack(void); 				
void IIC_Ack(void);					
void IIC_NAck(void);				
 
void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr);
uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead);


void  read_AHT20_once(void);
void  reset_AHT20(void);
void  init_AHT20(void);	
void  startMeasure_AHT20(void);
void  read_AHT20(void);
uint8_t  Receive_ACK(void);
void  Send_ACK(void);
void  SendNot_Ack(void);
void I2C_WriteByte(uint8_t  input);
uint8_t I2C_ReadByte(void);	
void  set_AHT20sendOutData(void);
void  I2C_Start(void);
void  I2C_Stop(void);
#endif

下一个sys.c

#include "sys.h"



void NVIC_Configuration(void)
{

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	//éè??NVIC?D??·?×é2:2???à??ó??è??￡?2???ìó|ó??è??

}

下一个sys.h

#include "sys.h"



void NVIC_Configuration(void)
{

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	

}

在固件库的基础上填入usart I2C sys 系统配置等各种环境配置
在这里插入图片描述
这里是读取aht20里面的信息

void  read_AHT20_once(void)
{
	delay_ms(10);

	reset_AHT20();   //reset是重新置位
	delay_ms(10);

	init_AHT20();     //iint初始化aht
	delay_ms(10);

	startMeasure_AHT20();    //明显，这是开始测量
	delay_ms(80);

	read_AHT20();       //这是一个读取传感器的数据
	delay_ms(5);
}

下面是串口通信的数据实现

先使用flymcu烧录进入芯片，
然后使用sccom 来继续串口通信。
在这里插入图片描述
上面那个是初始的室温和湿度
下面那个是对着aht20了一口气过后的温湿度，可以明显看到其变化。
在这里插入图片描述

参考文献：https://blog.csdn.net/qq_43279579/article/details/111597278

HMS-Erebus
关注
awk指定输入分隔符，输出分隔符
qq_21478261的博客
03-26 1029
FS='@' ，指定输入分割符为@OFS=','，指定输出分割符为,
awk 多字符分隔符
10-07 4412
多字符作为分隔符： 一，如果是A或B的关系的话就用 echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 结果是 x|xx|xxx 二，如果是AB整体作为分隔符 echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 结果是 x|xx 三，一个特别情况
Linux awk将文件某列按照逗号分隔的例子
09-15
今天小编就为大家分享一篇关于Linux awk将文件某列按照逗号分隔的例子，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
掌握awk中打印输出的高级技巧
最新发布
weixin_42602726的博客
04-11 316
本篇博客深入探讨了awk中的打印输出技巧，包括使用printf进行格式化输出、输出重定向到文件或管道、以及特殊文件名的使用。通过实际案例和代码示例，展示了如何利用这些技巧提高awk脚本的输出质量和效率。
awk按照多个分隔符进行分割
热门推荐
hongchangfirst
05-22 15万+
我们知道awk可以进行类似于cut之类的操作，ru
awk支持多个记录分隔符的写法
weixin_34127717的博客
05-05 889
awk的-F参数可以指定新的记录分隔符，有些时候可能需求指定多个分隔符，比如下面的内容width:720height:360如果需要取出width和height后面的值的话，一般大家会这样做，即做两次awk操作#echo"width:720height:360"|awk'{print$1;print$2}'|awk-F:'{print$2}' 72...
linux awk 多分隔符
zhenghe12365的博客
02-01 1864
上面虽然介绍了awk中使用多个记录分隔符的写法，但是这些记录分隔符都是单个字符，如果记录分隔符是个字符串怎么办呢？其实呢，通过在awk中指定两个记录分隔符（空格和:），即可一次性的提取出width和height后面的值，在awk中支持多个记录分隔符的写法如下。之前说过，awk支持正则表达式形式的记录分隔符，那就写个正则表达式就好，比如要指定分隔符为one和two。awk的-F参数可以指定新的记录分隔符，有些时候可能需求指定多个分隔符，比如下面的内容。
awk linux 分隔_awk多分隔符
weixin_39862097的博客
12-22 1287
awk的-F参数可以指定新的分隔符，有些时候可能需求指定多个分隔符，比如下面的内容[root@N1 ~]# netstat -an | grep ESTABudp 0 0 192.168.1.120:35570 212.47.249.141:123 ESTABLISHEDudp 0 0 192.168.1.120:55589 ...
Linux 三剑客之awk（二）分隔符
bigblue00的博客
09-17 1017
awk的默认分割符是空格，其实awk的分隔符还分为两种，“输入分隔符” 和 “输出分隔符” 。 输入分隔符，英文原文为field separator，此处简称为FS 输入分割符，默认是空白字符(即空格)，awk默认以空白字符为分隔符对每一行进行分割。 输出分割符，英文原文为output field separator，此处简称为OFS awk将每行分割后，输出在屏幕上的时候，以什么字符作为分隔符，awk默认的输出分割符也是空格。 输入分隔符 输入分隔符比较容易理解，当awk逐行处理文本的时候，以输入分隔符为
linux-shell脚本命令：awk命令简介
07-27
Linux系统中的awk命令是一个功能强大的文本处理工具，它可以对输入（通常是文件）进行模式扫描和处理。awk命令常用于在Linux shell脚本中进行数据提取、文本转换、数据报告生成等操作。本文将对awk命令的基本知识...
实验87-Linux命令：awk命令1
08-08
其中，`options` 包括各种控制选项，如 `-F` 用于指定字段分隔符，`-v` 用于设置用户定义变量，`-f` 从脚本文件中读取awk命令等。还有像 `-mf` 和 `-mr` 用于设置内存限制，以及 `-W` 选项用于选择特定的行为模式，...
awk使用多分隔符进行数据切分
鱼爻
04-28 3274
假如我们数据是这样的： mshing#24-mshing@msezi.com|A zhynin#18|zhynin@msezi.com-B mm-12-mm@123-c 分割符号为#,-,|不同的符号而且每一行的格式还不一致。但是数据的格式都是一样的，我们想通过分隔符提取数据。 使用多次awk的方法行不通，但别忘了强大的awk是可以一次指定多次分隔符的。 上代码： mshing@remtor:~$ cat text.txt | awk -F '[#|-]' '{print $1, $2, $3, $4}'
[转]awk按照多个分隔符进行分割
阿基米德来了的博客
07-03 632
https://blog.csdn.net/hongchangfirst/article/details/25071937
awk指定分隔符
柳鲲鹏
11-25 8373
默认是空格，如果想用别的呢？ awk -F "." '{print $1 }'
awk(gawk)用法小结
weixin_30252155的博客
12-29 326
awk 用法：awk ' pattern {action} ' 变量名 含义ARGC 命令行变元个数ARGV 命令行变元数组FILENAME 当前输入文件名FNR 当前文件中的记录号FS 输入域分隔符，默认为一个空格RS ...
awk 分隔符 多个空格_awk多分隔符
weixin_42604188的博客
01-17 3944
一般我们在使用awk的过程中，分隔符可以使用默认的空格(默认可以省略)和指定分隔符的方式。默认格式：awk '{print $n}' filename #n为字段值如：echo"0123456"|awk'{print$2}'1指定分隔符的格式：awk -F':' '{print $n}' filename或awk -F: '{print $n}' filename #如按...
centos awk（awk按照多个分隔符进行分割）
lxy___的博客
06-01 1916
1、awk按照多个分隔符进行分割 源文件 [root@orange tool]# cat /sys/block/sda/queue/scheduler noop [deadline] cfq awk按照多个分隔符进行分割 [root@orange tool]# cat /sys/block/sda/queue/scheduler | awk '{print $2}' | awk -F '[][]' '{print $2;}' deadline ...
awk依照多个分隔符进行切割
weixin_34080571的博客
01-23 414
我们知道awk能够进行类似于cut之类的操作。如一个文件data例如以下 zhc-123|zhang hongchangfirst-99|zhang hongchang-100|zhang 假设我们 awk -F ‘-’ ‘{print $1;}’ data 会打印出 zhc hongchangfirst hongchang 可是假设我想依据多个分隔符进...
用awk进行多个分隔符分割文件
weixin_30455067的博客
08-23 304
比如我有一张日志信息0.txt，日志的内容格式大概如下 123|xy|/mm/22/xx|300233|ss|/xn/23/mn|10030000|ddddd|/jjjjj/22/nn|200003|mmm|/ffffff/222222/mmmmmm|111111999999999|rrrrrrrrr|/wwwwwwwwwwwwwww/33333333333333/ttttttttttttt|5...
awk 输出的分隔符
09-02
awk输出的分隔符可以通过使用-F参数来指定。比如使用-F,来指定以逗号作为分隔符。 例如：awk -F, '{print $1,$2,$3}' 会将以逗号分隔的内容分别输出。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [shell脚本之awk命令——分隔符介绍](https://blog.csdn.net/xb_2015/article/details/119971107)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [Linux：awk指定输入和输出分隔符](https://blog.csdn.net/liangbilin/article/details/108593296)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值