Shubham
Reputation: 1
Not Getting sim800 response correctly
I am struggling to get correct response (OK) from sim800L module that is connected with stm32f103. But through serial terminal (using USB to serial module) everything(sms, call,gprs) is working fine.
I am getting series of AAAAAAA........ . I tried it with echo off but same response
Reduced the timeout too.
here is my piece of code
#include "main.h"
#include "stdio.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "string.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
unsigned char E[]={10},G[]={34},S[]={26},C[]={13};
#define SUB HAL_UART_Transmit(&huart1,(unsigned char*)S,1,1000);
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;
/* USER CODE BEGIN PV */
unsigned char tx_buffer[50],rx_buffer[50]={'\0'};
uint8_t x=26;
char send_str[33]={'\0'};
char Num_str[11]={"xxxxxxxxxx"};
char sending_sms_str[65] = {'\0'};
unsigned char msg_str[50]="good morning shubham";
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_USART3_UART_Init(void);
/* USER CODE BEGIN PFP */
void sim800_init(void);
void sim800_call(void);
void sim800_sms(void);
void sim800_gprs(void);
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/*
void sim800_response(void)
{
char response[200];
for(int i = 0 ; i<200 ; i++)
{
response[i++] = HAL_UART_Receive(&huart1,(unsigned char *)rx_buffer,1,100);
}
HAL_Delay(200);
HAL_UART_Transmit(&huart3,(unsigned char *)response,strlen(response),100);
}
*/
void sim800_test(void)
{
HAL_UART_Transmit(&huart3,(uint8_t *)"AT\r",strlen("AT\r"),100);
HAL_Delay(300);
//HAL_UART_Transmit(&huart1,(uint8_t *) "AT+IPR=9600\\n" , strlen ("AT+IPR=9600\r\n"),100);
//HAL_Delay(200);
HAL_UART_Receive(&huart3,(uint8_t *)rx_buffer,sizeof(rx_buffer),100);
HAL_Delay(200);
//sim800_response();
HAL_UART_Transmit(&huart1,(uint8_t *)rx_buffer,sizeof(rx_buffer),100);// to Uart1 for debugging the response
HAL_Delay(200);
rx_buffer[0] = '\0';
}
void sim800_init(void)
{
HAL_Delay(10000);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT\r\n",strlen("AT\r\n"),1000);
HAL_Delay(500);
//-----------------------------
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+IPR=9600\r\n",strlen("AT+IPR=9600\r\n"),1000);
HAL_Delay(500);
}
void sim800_call(void) // working
{
char rxbuf[50];
HAL_UART_Transmit(&huart3,(uint8_t *)"ATD xxxxxxxxxx;\r\n",strlen("ATD xxxxxxxxxx;\r\n"),1000);
HAL_Delay(100);
HAL_UART_Receive(&huart3,(uint8_t *)rxbuf,strlen(rxbuf),300);
HAL_Delay(100);
HAL_UART_Transmit(&huart1,(uint8_t *)rxbuf,strlen(rxbuf),300);//to Uart1 for debugging the response
rxbuf[0]='\0';
HAL_Delay(10000);
HAL_UART_Transmit(&huart3,(uint8_t *)"ATH\r\n",strlen("ATH\r\n"),1000);
HAL_Delay(100);
HAL_UART_Receive(&huart3,(uint8_t *)rxbuf,strlen(rxbuf),300);
HAL_Delay(100);
HAL_UART_Transmit(&huart1,(uint8_t *)rxbuf,strlen(rxbuf),300);//to Uart1 for debugging the response
rxbuf[0]='\0';
}
void sim800_sms(void) // function 1 working
{
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CMGF=1\r\n",strlen("AT+CMGF=1\r\n"),1000);
//HAL_Delay(500);
//HAL_UART_Transmit(&huart1,(uint8_t *)"AT+CMGS=\"+91xxxxxxxxxx\"\r\n",strlen("AT+CMGS=\"+91xxxxxxxxxx\"\r\n"),1000);
//HAL_Delay(500);
//HAL_UART_Transmit(&huart1,(unsigned char *)"it is working",strlen("it is working"),1000);
//HAL_Delay(500);
//HAL_UART_Transmit(&huart1,(uint8_t *)&x,1,10);
HAL_Delay(500);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CMGS=\"+91xxxxxxxxxxx\"\r\n",strlen("AT+CMGS=\"+91xxxxxxxxxx\"\r\n"),1000);
HAL_Delay(500);
HAL_UART_Transmit(&huart3,(unsigned char *)msg_str,strlen((const char *)msg_str),1000);
HAL_Delay(500);
HAL_UART_Transmit(&huart3,(uint8_t *)&x,1,10);
HAL_Delay(5000);
}
void send_sms(void) // function 2 working
{
LED_GPIO_Port -> BRR = LED_Pin;
send_str[0] = '\0';
sprintf(send_str,"AT+CMGF=1\r\n");
HAL_UART_Transmit(&huart3,(unsigned char *)send_str,strlen(send_str),1000);
HAL_Delay(1000);
send_str[0] = '\0';
sprintf(send_str,"AT+CMGS=\"+91%s\"\r\n",Num_str);
HAL_UART_Transmit(&huart3,(unsigned char *)send_str,strlen(send_str),1000);
HAL_Delay(1000);
sprintf(sending_sms_str,"HELLO\r\n");
HAL_UART_Transmit(&huart3,(unsigned char *)sending_sms_str,strlen(sending_sms_str),1000);
//HAL_Delay(10);
//HAL_UART_Transmit(&huart1,(unsigned char*)S,1,1000); // or SUB
SUB
HAL_Delay(1000);
LED_GPIO_Port -> BSRR = LED_Pin;
}
void sim800_gprs(void)
{
HAL_UART_Transmit(&huart3,(uint8_t *)"AT\r\n",strlen("AT\r\n"),1000);
HAL_Delay(300);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CIPSHUT\r\n",strlen("AT+CIPSHUT\r\n"),1000);
HAL_Delay(300);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CIPMUX=0\r\n",strlen("AT+CIPMUX=0\r\n"),1000);
HAL_Delay(300);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CGATT=1\r\n",strlen("AT+CGATT=1\r\n"),1000);
HAL_Delay(300);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CSTT=\"www\",\"\",\"\"\r\n",strlen("AT+CSTT=\"www\",\"\",\"\"\r\n"),1000);
HAL_Delay(2000);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CIICR\r\n",strlen("AT+CIICR\r\n"),5000);
HAL_Delay(2000);
HAL_UART_Transmit(&huart3,(uint8_t *)"AT+CIFSR\r\n",strlen("AT+CIFSR\r\n"),1000);
HAL_Delay(1000);
HAL_UART_Transmit(&huart1,(uint8_t *)"All cmd sent\r\n",strlen("All cmd sent\r\n"),1000);
}
//---------------------------------------------------------------------//
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_USART1_UART_Init();
MX_USART3_UART_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
sim800_init();
sim800_gprs();
//sim800_call();
//sim800_test();
//sim800_init();
//sim800_call(); // working but reliability low
//send_sms(); // working but reliability very low
// sim800_sms(); // working
//HAL_Delay(25000);
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief USART1 Initialization Function
* @param None
* @retval None
*/
static 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 = 9600;
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 */
}
/**
* @brief USART3 Initialization Function
* @param None
* @retval None
*/
static void MX_USART3_UART_Init(void)
{
/* USER CODE BEGIN USART3_Init 0 */
/* USER CODE END USART3_Init 0 */
/* USER CODE BEGIN USART3_Init 1 */
/* USER CODE END USART3_Init 1 */
huart3.Instance = USART3;
huart3.Init.BaudRate = 9600;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART3_Init 2 */
/* USER CODE END USART3_Init 2 */
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin : LED_Pin */
GPIO_InitStruct.Pin = LED_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(LED_GPIO_Port, &GPIO_InitStruct);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif
Upvotes: 0
Views: 1417
Answers (1)
Bayrem Gharsellaoui
Reputation: 308
I would suggest the following to debug the problems you're facing:
- You need to make sure that your UART code is working correctly, to do that you can connect your STM32 to a serial terminal on your PC via an FTDI cable and check if the messages sent from the STM32 are received on the serial terminal.
- Once step (1) is resolved, you need to check that you are powering your SIM800 module correctly (ie: correct power pin and enough current).
- Once step (2) is resolved try to connect the SIM800 to your PC via an FTDI cable and send & receive AT commands and responses via a serial monitor.
Back to the code here are some simple examples on how to send an AT command and wait for its known response:
With Echo:
/* Wait at most 1000 ms for the command to be sent completely */
HAL_UART_Transmit(&huart3,(uint8_t *)"AT\r", (sizeof("AT\r")-1), 1000);
/* Wait 5000 ms for response with echo */
HAL_UART_Receive(&huart3, (uint8_t *)rx_buffer, (sizeof("AT\r\r\nOK\r\n")-1), 5000);
Without echo:
/* Wait at most 1000 ms for the command to be sent completely */
HAL_UART_Transmit(&huart3,(uint8_t *)"AT\r", (sizeof("AT\r")-1), 1000);
/* Wait 50000 ms for response without echo */
HAL_UART_Receive(&huart3, (uint8_t *)rx_buffer, (sizeof("\r\nOK\r\n")-1), 5000);
OR you can do it asynchronously via the UART receive callback:
With Echo:
/* Wait at most 1000 ms for the command to be sent completely */
HAL_UART_Transmit(&huart3,(uint8_t *)"AT\r", (sizeof("AT\r")-1), 1000);
/* This will raise a callback when the response length is reached */
HAL_UART_Receive_IT(&huart3, (uint8_t *)rx_buffer, (sizeof("AT\r\r\nOK\r\n")-1));
Without echo:
/* Wait at most 1000 ms for the command to be sent completely */
HAL_UART_Transmit(&huart3,(uint8_t *)"AT\r", (sizeof("AT\r")-1), 1000);
/* This will raise a callback when the response length is reached */
HAL_UART_Receive_IT(&huart3, (uint8_t *)rx_buffer, (sizeof("\r\nOK\r\n")-1));
Callback:
HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART3)
{
/* if you are here then you received a response */
}
}
Upvotes: 2
Related Questions
- Program is executing but AT commands not showing in serial monitor
- SIM800L GSM module not connect to network
- SIM900 AT Commands response parsing
- STM32 GSM AT command response parser
- SIM800L Blank SMS issue
- SIM800L CIPSEND error, cannot make requests
- Error: Invalid number format while sending SMS with SIM800L
- send SMS with SIM 900 with st nucleo
- SIM900 GSM/GPRS not getting a proper AT+CREG? answer
- Not getting response from GSM Modem using AT command