USART von Microcontroller zu GSM Modul funktioniert nicht

[Sam_Oe1 (Gast)]

Hallo,

im Bereich Embedded Systems bin ich relativ neu und für ein 
Studienprojekt sollen SMS-Nachrichten mittels einem Microcontroller via 
GSM versendet werden.

Dafür nutze ich einen Nucleo-STM32L476RGT6 Microcontroller und ein 
MIKROE LTE Cat.1 Click Board GSM Modul 
(https://www.mikroe.com/lte-cat1-eu-click-for-europe). Als 
Programmierumgebung nutze ich STM32CubeIDE.

Da GSM Module im Allgemeinen per "AT-Kommandos" kommunizieren, habe ich 
erstmal das GSM Modul per USB angeschlossen und die AT Kommandos über 
ein COM Terminal manuell eingegeben. Es hat funktioniert.

Nun war meine Idee: AT Befehle per HAL_UART_Transmit zu versenden und 
die Rückmeldung vom GSM Modul per HAL_UART_Receive zu empfangen.

Für das Erste möchte ich nur den Befehl "AT" senden um zu testen, ob der 
Befehl überhaupt ankommt und möchte diesen auch per Receive mit "OK" 
empfangen.

Hierfür benutze ich 2 USART's:
- USART2 für die Kommunikation mit dem Terminal (USB), Baudrate: 115200

- USART1 für die Kommunikation mit dem GSM Modul, Baudrate: 9600
   - PA10: USART1_RX
   - PA9:  USART1_TX

Die RX und TX Pins habe ich an die TX und RX Pins des GSM Moduls mit 5v 
und GND angeschlossen (Siehe Bild im Anhang: MC_GSM_Anschluss_UART).

Im Datasheet des Microcontrollers habe ich gelesen, dass die I/O 
Struktur der PA10 und PA9 Pins FT sind, also 5V tolerant. Laut der 
Schematic des GSM Moduls arbeiten die RX und TX Pins auch mit 3V3. Daher 
sollte das eigentlich kein Problem sein (Siehe Anhang).

Jedoch bekomme ich in der Konsole kein"OK" zurück bzw. es kommt gar 
nichts an. Daraus schließe ich, dass der Microcontroller den 
HAL_UART_Transmit(&huart1) Befehl mit "AT"  nicht an das GSM Modul 
übermittelt.

Woran könnte das liegen? Ich habe USART3 auch schon probiert jedoch mit 
dem gleichen Ergebnis.

Langsam weiß ich nicht mehr weiter.. ich bin für jede Hilfe wirklich 
sehr dankbar!

Das main.c Programm habe ich so aufgebaut:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"


/* Private variables ---------------------------------------------------------*/
 UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;



/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_USART1_UART_Init(void);

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
char Test[]="AT";
char Reply[]="";


  
int main(void)
{


  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
  SystemClock_Config();

 
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_USART1_UART_Init();
 
  while (1)
  {
    /* USER CODE END WHILE */
    
    HAL_UART_Transmit(&huart1,(uint8_t *)"AT",strlen("AT"),1000);     //Send AT Command
    HAL_UART_Receive(&huart1,(uint8_t *)Reply,5,1000);        //Receive AT Result 

    HAL_UART_Transmit(&huart2,(uint8_t *)Reply,strlen(Reply),1000);  //Send Result to Terminal
    
  }
  
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 1;
  RCC_OscInitStruct.PLL.PLLN = 10;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != 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;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static 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;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_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_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_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 /* USE_FULL_ASSERT */

[NichtWichtig (Gast)]

Schon mal per debugger durch gestept?

[Thomas W. (Gast)]

Wichtige Regeln - erst lesen, dann posten!

    Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang


Hat schon seinen Grund.

Dieser AT-Kommandos kommen aus der Zeit, als Daten mit Modems verschickt 
wurden. Daher sind einige Sachen etwas archaisch:
- AT oder ATZ sind ueberlicherweise AT\r\n oder ATZ\r\n, Du musst den 
Zeilentrenner mitschicken. Sonst wartet das Modem.

- char Test[]="AT"; ein \0 als String-Trenner waere nicht schlecht.

- Du musst im Endeffekt einen Ringbuffer implementieren. Du koenntest 
mal bei Controllers Tech gucken, wie man das so macht (der Autor hat ein 
Video genau fuer Deinen Fall gemacht).

https://controllerstech.com/ring-buffer-using-head-and-tail-in-stm32/
https://github.com/controllerstech/stm32-uart-ring-buffer

Gruesse

Th.

[DerEgon (Gast)]

Thomas W. schrieb:
> char Test[]="AT"; ein \0 als String-Trenner waere nicht schlecht.

Das \0 steht da. Das ist implizit, wenn ein char-Array mit einer 
Stringkonstanten initialisiert wird.

sizeof Test ist hier 3, nicht 2.

[Frank K. (fchk)]

Sam_Oe1 schrieb:

> Dafür nutze ich einen Nucleo-STM32L476RGT6 Microcontroller und ein
> MIKROE LTE Cat.1 Click Board GSM Modul
> (https://www.mikroe.com/lte-cat1-eu-click-for-europe). Als
> Programmierumgebung nutze ich STM32CubeIDE.

Erster Haken: Diese Module können kurzzeitig (innerhalb einiger ms) 
einige Ampere ziehen. Wenn die die nicht bekommen, dann geht entweder 
gar nichts oder manchmal nichts oder oder oder. Ich weiß nicht ganz, ob 
Dein Nucleo-Board diese Anforderung erfüllt. Dass da ein passender 
Steckplatz drauf ist, sagt erstmal überhaupt nichts aus.

Schritt 1 ist also die Stromversorgung. Ohne die geht gar nichts.

> Nun war meine Idee: AT Befehle per HAL_UART_Transmit zu versenden und
> die Rückmeldung vom GSM Modul per HAL_UART_Receive zu empfangen.

sollte funktionieren.

> Hierfür benutze ich 2 USART's:
> - USART2 für die Kommunikation mit dem Terminal (USB), Baudrate: 115200
>
> - USART1 für die Kommunikation mit dem GSM Modul, Baudrate: 9600
>    - PA10: USART1_RX
>    - PA9:  USART1_TX

Hier darfst/solltest Du die Baudrate auch auf 115200 setzen.

> Jedoch bekomme ich in der Konsole kein"OK" zurück bzw. es kommt gar
> nichts an. Daraus schließe ich, dass der Microcontroller den
> HAL_UART_Transmit(&huart1) Befehl mit "AT"  nicht an das GSM Modul
> übermittelt.

Diese Schlussfolgerung ist möglicherweise falsch. Besorge Dir einen 
Logicanalyzer. Suche bei Amazon nach "logic analyzer 24mhz 8ch" und nimm 
irgendeinen davon. Das sind alles Nachbauten von einem 
Originalhersteller. Preis so zwischen 10 und 15€. Damit kannst Du dann 
nachschauen, was wirklich auf dem seriellen Bus abgeht. Die Software 
decodiert Dir auch die Bytes usw. Dieses kleine Teil ist ein Must-Have 
für Dich.

Schritt 3: Nimm als Gegenstelle einen PC mit USB-UART Interface. Da 
weißt Du, dass das funktioniert. Schau, dass Deine Hardware funktioniert 
und Du Bytes senden und empfangen kannst und dass die auch tatsächlich 
auf dem Logic Analyzer auftauchen.

Schritt 4: Jetzt erst kommt das Modem ins Spiel.

Anmerkung: AT-Befehle fangen immer mit "AT" oder "at" an und enden 
grundsätzlich mit einem CR ('\r', Character Code dezimal 13 = hex 0x0d). 
Ohne das '\r' bekommst Du kein OK.

fchk

[Harry L. (mysth)]

Bei deinem AT-String fehlt das CR am Ende.
Bei Receive blockierend zu warten bis 5 Zeichen eingetroffen sind, ist 
auch keine besonders gute Idee.

[Volker B. (Firma: L-E-A) (vobs)]

Harry L. schrieb:

> Bei Receive blockierend zu warten bis 5 Zeichen eingetroffen sind, ist
> auch keine besonders gute Idee.

Vor allem, wenn die genutzte Puffer-Variable Reply[] nur Platz für 1 
Byte hat.
Zitat:

char Reply[]="";

Grüßle
Volker

[Helmut -. (dc3yc)]

Du kannst auch erst mal einen Loopback-Test machen, indem du Sender und 
Empfänger des Nucleos kurzschließt und schaust, ob deine gesendeten 
Zeichen wieder rückgelesen werden.

[Samet Ö. (sam_oe1)]

Vielen Dank für die Antwort.

Bezüglich der Stromversorgung: Sobald ich den Microcontroller an das 
Breadboard mit 5V und GND und das GSM Modul an das Breadboard 
anschließe, leuchten am Modul 2 LED's (PWI und PWR). Kann ich daraus 
schließen, dass die Stromversorgung soweit passt?

> Hier darfst/solltest Du die Baudrate auch auf 115200 setzen.
>
Die Baudrate habe ich soweit angepasst.

> Suche bei Amazon nach "logic analyzer 24mhz 8ch" und nimm
> irgendeinen davon.
>
Sehr guter Hinweis, werde ich mir gleich bestellen.

> Schritt 3: Nimm als Gegenstelle einen PC mit USB-UART Interface. Da
> weißt Du, dass das funktioniert. Schau, dass Deine Hardware funktioniert
> und Du Bytes senden und empfangen kannst und dass die auch tatsächlich
> auf dem Logic Analyzer auftauchen.

Ich habe HAL_UART_Transmit(&huart2, XX) mit "TEST\r\n" in der IDE 
getestet und ich empfange ein "TEST" im Terminal.
Zusätzlich habe ich das GSM Modul über USB angeschlossen und "AT" 
manuell über die PuTTY (COM5) Konsole eingegeben. Ich bekomme ein "OK" 
zurück.

> Anmerkung: AT-Befehle fangen immer mit "AT" oder "at" an und enden
> grundsätzlich mit einem CR ('\r', Character Code dezimal 13 = hex 0x0d).
> Ohne das '\r' bekommst Du kein OK.

Ich habe es mit "AT\r\n" probiert, leider ohne Erfolg.

Grüße
Sam_oe1

[Samet Ö. (sam_oe1)]

Danke für die Antwort!

Thomas W. schrieb:
> - Du musst im Endeffekt einen Ringbuffer implementieren. Du koenntest
> mal bei Controllers Tech gucken, wie man das so macht (der Autor hat ein
> Video genau fuer Deinen Fall gemacht).
>
> https://controllerstech.com/ring-buffer-using-head-and-tail-in-stm32/
> https://github.com/controllerstech/stm32-uart-ring-buffer

Das mit dem Ringbuffer werde ich gleich testen.

Grüße
Sam_oe1

[Frank K. (fchk)]

Samet Ö. schrieb:

> Bezüglich der Stromversorgung: Sobald ich den Microcontroller an das
> Breadboard mit 5V und GND und das GSM Modul an das Breadboard
> anschließe, leuchten am Modul 2 LED's (PWI und PWR). Kann ich daraus
> schließen, dass die Stromversorgung soweit passt?

Nein, das sagt gar nichts aus.

Hier ist das Hardware-Datenblatt für das nackte Modul.
https://cdn.papouch.com/data/user-content/products/gsm-els61-e2n/els61-e_hid_v01.000.pdf

Das Modul will kurzzeitig 2.3A sehen, wenn es sendet. Dafür musst Du 
direkt an den Versorgungspins Kondensatoren als Puffer plazieren, 
mindestens einen keramischen mit 4.7 bis 10uF (gerne mehrere kleinere 
anstelle eines großen) und 16V Nennspannung und einen Tantal mit 
220uF/10V. Das Netzteil sollte also 3A nur für das Modul sicher liefern 
können.

Nachprüfen mit Oszi gemäß Hardwarebeschreibung.

> Ich habe HAL_UART_Transmit(&huart2, XX) mit "TEST\r\n" in der IDE
> getestet und ich empfange ein "TEST" im Terminal.

Und die Gegenrichtung geht auch?

> Zusätzlich habe ich das GSM Modul über USB angeschlossen und "AT"
> manuell über die PuTTY (COM5) Konsole eingegeben. Ich bekomme ein "OK"
> zurück.
ok, das sagt jetzt nichts aus.

>> Anmerkung: AT-Befehle fangen immer mit "AT" oder "at" an und enden
>> grundsätzlich mit einem CR ('\r', Character Code dezimal 13 = hex 0x0d).
>> Ohne das '\r' bekommst Du kein OK.
>
> Ich habe es mit "AT\r\n" probiert, leider ohne Erfolg.

Dann liegt es daran nicht.

fchk

[Samet Ö. (sam_oe1)]

Samet Ö. schrieb:
> Danke für die Antwort!
>
> Thomas W. schrieb:
>> - Du musst im Endeffekt einen Ringbuffer implementieren. Du koenntest
>> mal bei Controllers Tech gucken, wie man das so macht (der Autor hat ein
>> Video genau fuer Deinen Fall gemacht).
>>
>> https://controllerstech.com/ring-buffer-using-head-and-tail-in-stm32/
>> https://github.com/controllerstech/stm32-uart-ring-buffer
>
> Das mit dem Ringbuffer werde ich gleich testen.
>
> Grüße
> Sam_oe1

Ich habe das Beispiel mit dem Ringbuffer getestet und es hat nicht 
funktioniert. Bei diesem Projekt wird nur ein UART Anschluss verwendet 
bzw. eine Kommunikation mit einem zweiten Modul findet hier nicht statt.

Zudem werden die Zeichen über die Tastatur am COM Terminal eingegeben. 
Ich möchte diese Zeichen per HAL_UART_Transmit automatisiert übertragen. 
Im Programm gab es zusätzlich Komplikationen bezüglich den zwei UARTs. 
Mein Professor meinte ein Ringbuffer wäre in diesem Fall nicht 
notwendig.

Ich werde es weiter probieren. Notfalls werde ich versuchen das GSM 
Modul via I2C oder SPI anzuschließen.

Dennoch danke für die Hilfe.

[Stefan F. (Gast)]

Samet Ö. schrieb:
> Kann ich daraus schließen, dass die Stromversorgung soweit passt?

Das sollte in der Anleitung des Moduls stehen. Wenn du keine hast, frage 
den Händler. Es ist nicht unser Job, die Arbeit des Händler zu 
erledigen. Schließlich ist er derjenige, der den Gewinn kassiert.

Besorge dir wie gesagt einen Logic Analyzer, mit dem kannst du die 
serielle Kommunikation analysieren.

Laut Beschreibung unterstützt das Modul Handshake Leitungen an zwei 
seriellen ports, welche per AT Befehl konfiguriert werden müssen. Hast 
du das gemacht? Wenn dabei die Handshake Leitungen aktiviert wurden, 
muss man sie auch passend ansteuern.

Es wäre aber auch durchaus vorstellbar, dass die aktuell installierte 
Firmware nur den USB Port unterstützt. Ich hatte mal Bluetooth Module 
die hatten ebenfalls viele Schnittstellen, aber nur eine davon konnte 
mit der Firmware genutzt werden.

Du brauchst die Bedienungsanleitung von genau der Firmware, die sich in 
dem Modul befindet.

[Samet Ö. (sam_oe1)]

Hallo,

vielen Dank für die vielen Antworten. Ich habe es hinbekommen. Am GSM 
Modul hat nur das USB-Kabel gefehlt. D.h. ich musste sowohl die RX, TX, 
5V und GND Pins als auch das USB Kabel für die externe Stromversorgung 
an einem zweiten USB-Port anschließen.

Nun funktioniert die Kommunikation des Microcontrollers mit dem GSM 
Modul über

HAL_UART_Transmit(&huart1,(uint8_t *)"AT\r\n",strlen("AT\r\n"),1000);

.
Das "OK" Signal empfange ich mit

HAL_UART_Receive(&huart1,(uint8_t *)Reply,sizeof(Reply),1000);

 und gebe es am Terminal aus mit

HAL_UART_Transmit(&huart2,(uint8_t *)Reply,sizeof(Reply),1000);

.

Vielen Dank für die Hilfe!

Grüße
Sam_oe1

[Stefan F. (Gast)]

Samet Ö. schrieb:
> D.h. ich musste sowohl die RX, TX,
> 5V und GND Pins als auch das USB Kabel für die externe Stromversorgung
> an einem zweiten USB-Port anschließen.

Na ob da alles mit rechten Dinge zugeht? Ich meine, das sollte auch ohne 
USB Verbindung funktionieren, wie bei allen anderen Modulen auch.

Ein kleiner Tipp zum Programmierstil:

HAL_UART_Transmit(&huart1,(uint8_t *)"AT\r\n",strlen("AT\r\n"),1000);

Das ist ziemlich fehlerträchtig, wenn du später mal den String änderst. 
Außerdem ist strlen() eine Funktion die zur Laufzeit ausgeführt wird. Da 
die Länge des String aber unveränderlich ist, vergeudest du damit 
unfassbar viel Rechenleistung die das Klima kaputt macht und uns alle in 
den Weltuntergang reißt.

Vorschlag:

const char[] command_at="AT\r\n";
HAL_UART_Transmit(&huart1,(uint8_t *)command_at,sizeof(command_at),1000);

[STK500-Besitzer (Gast)]

Stefan ⛄ F. schrieb:
> Vorschlag:

 const char[] command_at="AT\r\n";
 HAL_UART_Transmit(&huart1,(uint8_t *)command_at,sizeof(command_at)-1,1000);

strlen zählt die Zeichen im String, aber nicht das Endezeichen.
sizof liefert die komplette Arraylänge inkl. Endezeichen.

[Stefan F. (Gast)]

STK500-Besitzer schrieb:
> strlen zählt die Zeichen im String, aber nicht das Endezeichen.
> sizof liefert die komplette Arraylänge inkl. Endezeichen.

Ja stimmt. Danke für die Korrektur

[avr (Gast)]

Und abgesehen davon ist es schlechter Stil an den Stellen sizeof 
einzusetzen, nicht umgekehrt. strlen wird genau an diesen Stellen zur 
Compilezeit ausgewertet. Wenn man nicht zu 100% weiß was man tut, sollte 
man immer die leserliche Variante bevorzugen.

Also bitte nicht mit sizeof-1 Konstrukten anfangen.