AT指令发送失败

DVA_IS_QAQ · 2022 年8 月 16 日 06:26

100ask_Alen · 2022 年8 月 16 日 06:28

信息太少，看不出来啥。
你是使用的示例代码还是自己写的代码呢？
使用示例代码的话，告知下用的哪一个
自己写的代码的话，优先去对比下示例代码，找找是哪里不同，然后自己尝试分析下原因

DVA_IS_QAQ · 2022 年8 月 16 日 06:31

就是按照示例代码来写的，别的AT指令都可以发送成功，唯独这个不行
示例代码的可以发送成功

100ask_Alen · 2022 年8 月 16 日 06:37

哪一个示例代码？
示例代码可以，那说明你的代码，在细节处，和示例代码有不同
1.仔细对比；
2.使用调试器单步调试，看看发送这个指令后收到的反馈，和示例代码的有何区别。

DVA_IS_QAQ · 2022 年8 月 16 日 07:11

现在ESP8266发送给小程序的指令可以发送成功，但是小程序没有反应是什么原因？

100ask_Alen · 2022 年8 月 16 日 07:25

先让小程序发指令给esp8266，然后再让esp8266发给小程序看看

DVA_IS_QAQ · 2022 年8 月 16 日 08:36

接收小程序的功能可以实现，但是发送不知道为什么不行

100ask_Alen · 2022 年8 月 16 日 09:16

你给的信息太少了，你的这些信息太零碎，整理好，把你的代码贴出来，不然怎么给你定位问题？
你是参加的7天物联网训练营吗
还是看的什么视频。

DVA_IS_QAQ · 2022 年8 月 16 日 09:16

我看的七天物联网视频

100ask_Alen · 2022 年8 月 16 日 09:17

DVA_IS_QAQ · 2022 年8 月 16 日 09:18

DVA_IS_QAQ · 2022 年8 月 16 日 09:18

100ask_Alen · 2022 年8 月 16 日 09:22

要学会问问题呀小伙伴

你的这个表述，谁发送给谁不行？
如果是小程序发给开发板，那你是不是应该贴一下你开发板处理接收网络数据的代码？
如果是开发板发给小程序，那你是不是应该先确保你开发板的程序把你的指令或者数据发出去了？这个怎么确保？程序中加printf打印或者使用调试器调试，观察现象。
还有，你应该学会调试，去调试中发现定位问题，这样才能成长呀。
如果碰到问题就直接来要答案，你如果是追求一个快速开发，那没啥问题；如果是学习，那这样怎么会有好的学习效果呢，你说是不是

100ask_Alen · 2022 年8 月 16 日 09:23

像你贴的这些代码，我们只能看到你调用了哪些函数，没法看到你这些函数的细节，谁都帮不了你。

DVA_IS_QAQ · 2022 年8 月 16 日 09:31

DVA_IS_QAQ · 2022 年8 月 16 日 09:31

开发板的命令发送不过去

100ask_Alen · 2022 年8 月 16 日 09:40

把你usart.c的所有代码都贴出来

DVA_IS_QAQ · 2022 年8 月 16 日 09:44

#include "usart.h"

/* USER CODE BEGIN 0 */
#include <stdio.h>
#include <string.h>

uint8_t rx_data;
uint8_t Rx_data_buf[200];
uint8_t i=0;




void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
			Rx_data_buf[i%200]=rx_data;
			i++;
			HAL_UART_Receive_IT(&huart2, (uint8_t *)&rx_data, 1);

}

uint16_t USART_Receive(uint8_t *pdata)
{
	memcpy(pdata,(uint8_t *)&Rx_data_buf,i);
	return i;
}

void USART_Transmit(uint8_t *pData, uint16_t Size, uint32_t Timeout)
{
	HAL_UART_Transmit(&huart2,pData, Size,Timeout);
}

void USART2_Clear(void)
{
	i=0;
	memset((uint8_t *)&Rx_data_buf,0,200);
}


// 向ESP8266发送AT指令
uint8_t ESP8266_SendCmd(char *cmd,char *reply,uint16_t timeout)
{
	// 1.保存传入的指令
	char buf[256]={0};
	strcat(buf,cmd);
	
	// 2.处理AT指令
	if(strstr(buf,"\r\n")==0)
	{
		strcat(buf,"\r\n");
	}
	
	// 3.清理前面接收的buf,是中断接收到的
	USART2_Clear();
	
	// 4.发送数据
	USART_Transmit((uint8_t  *)buf,sizeof(buf),500);

	// 5.接收数据
	memset((uint8_t *)&buf,0,256);
	while(timeout!=0)
	{
			if(USART_Receive((uint8_t  *)buf))
			{
				if(strstr(buf,reply))
				{
					printf("%s Send Successful!\r\n",cmd);
					if(strstr(buf, "STAIP"))
					{
						printf("%s\r\n", buf); // 打印IP地址
					}
					return 0;
				}
				else
				{
					timeout--;
					HAL_Delay(1);
				}
			}	
	}
	printf("%s error!\r\n",cmd);
	return 1;
}

uint8_t ESP8266_Send_TCP(char *data)
{
	// 1.准备发送的指令
	char buf[256] = {0};
	uint8_t len = strlen(data);
	sprintf(buf, "AT+CIPSEND=0,%d\r\n", len);
	// 2.发送指令
	if (ESP8266_SendCmd(buf, "OK", 500) == 0)
	{
		// 3.发送数据
		ESP8266_SendCmd(data, "OK", 1000);
		return 0;
	}
	return 1;
}

/* USER CODE END 0 */

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;

/* USART1 init function */

void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}
/* USART2 init function */

void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspInit 0 */

  /* USER CODE END USART1_MspInit 0 */
    /* USART1 clock enable */
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN USART1_MspInit 1 */

  /* USER CODE END USART1_MspInit 1 */
  }
  else if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspInit 0 */

  /* USER CODE END USART2_MspInit 0 */
    /* USART2 clock enable */
    __HAL_RCC_USART2_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART2 GPIO Configuration
    PA2     ------> USART2_TX
    PA3     ------> USART2_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_2;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART2 interrupt Init */
    HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspInit 1 */

  /* USER CODE END USART2_MspInit 1 */
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{

  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspDeInit 0 */

  /* USER CODE END USART1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART1_CLK_DISABLE();

    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);

  /* USER CODE BEGIN USART1_MspDeInit 1 */

  /* USER CODE END USART1_MspDeInit 1 */
  }
  else if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspDeInit 0 */

  /* USER CODE END USART2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART2_CLK_DISABLE();

    /**USART2 GPIO Configuration
    PA2     ------> USART2_TX
    PA3     ------> USART2_RX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3);

    /* USART2 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspDeInit 1 */

  /* USER CODE END USART2_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */
int fputc(int ch, FILE *f)
{
	HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 10);
	return ch;
}

/*****************************************************
*function: 读字符文件函数
*param1: 文件指针
*return: 读取字符的 ASCII 码
******************************************************/
int fgetc(FILE *f)
{
	uint8_t ch = 0;
	HAL_UART_Receive(&huart1, (uint8_t*)&ch, 1, 10);
	return (int)ch;
}
/* USER CODE END 1 */

DVA_IS_QAQ · 2022 年8 月 16 日 09:51

有时候开发板可以发送成功，有时候不行，但是最后小程序都是没反应

100ask_Alen · 2022 年8 月 16 日 09:55

你在做哪一天的实验？参考的是code几的代码？