Bonjour à tous,

Je découvre la programmation autour des cartes ST ....

Je me suis lancé dans la mise en oeuvre de la communication UART entre deux cartes nucleos 767ZI. J'aimerais pouvoir échanger des messages entre chacune d'entre elles et afficher le contenu sur un terminal.

Après avoir navigué sur le web et testé différents codes je n'arrive toujours pas à afficher les données échangées.

J'ai téléchargé les sofwares STM32CubeIDE ainsi que STM32CubeProg.

Je me suis fait un ptit shéma qui explique la manip que je veux monter.

Voici le code que j'ai compilé puis debuggé .... (Vous pouvez voir qu'il y a de nombreux printf que je n'arrive pas à faire afficher sur la console du terminal).

Je vous remercie par avance,

Code carte émettrice:

Code carte Réception:

Hello,

Plutôt que de poster ton code en image, tu devrais utiliser la balise dédiée à cet effet : le petit bouton </> au dessus de la zone d'édition du text (bouton qui se trouve juste à droite du bouton d'insertion d'une image).

Niveau raccordement, sur les 2 processeurs sont reliés au même PC par USB, on peut envisager le fait qu'ils partagent le même GND et que cela puisse marché, bien que pas optimal car cette liaison GND passe par les câble et le PC.

Mais si il s'agit de 2 PC différents, alors il n'y a pas de liaison GND et cela ne marchera jamais.

Du coup, la première chose à faire serait de relier ensemble le GND de tes 2 cartes.

Serait-il possible de voir comment tu as implémenté les différentes fonctions Init ?

Vois tu s'afficher les messages "debut du transfert" et "debut réception" ?

Par défaut, printf ne fait rien.

Il faut:

• activer le port série qui est connecté au PC (USART3 sur PD8 et PD9 pour le port série relié à la partie ST-LINK),
• rediriger putchar/fputc sur ce port série

Tu as normalement un exemple qui est automatiquement téléchargé avec le firmware de ta carte par stm32cube mx ou ide (dans C:\Utilisateurs\<tonLogin>\STM32Cube\Repository\<Le FW de ta carte>\Projects\<TaCarte>\Example\UART\UART_Printf).

En résumé, il y a 2 morceaux de code à copier du fichier main.c de l'exemple dans ton fichier main.c (en plus de l'initialisation de USART3):

#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
   set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */

/**
  * @brief  Retargets the C library printf function to the USART.
  * @param  None
  * @retval None
  */
PUTCHAR_PROTOTYPE
{
  /* Place your implementation of fputc here */
  /* e.g. write a character to the USART3 and Loop until the end of transmission */
  HAL_UART_Transmit(&huart3, (uint8_t *)&ch, 1, 0xFFFF);
 
  return ch;
}

Il est aussi possible d'utiliser le port USB natif et son port série virtuel (USB CDC), mais c'est probablement plus compliqué.

Bonjour,

Je vous remercie pour vos réponses,

Je m'excuse de répondre aussi tardivement,

J'ai créé un nouveau projet pour tester le printf: 

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f7xx_hal.h"
#include "stdio.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */
#ifdef __GNUC__
/* With GCC, small printf (option LD Linker->Libraries->Small printf
   set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

UART_HandleTypeDef huart2;
UART_HandleTypeDef huart3;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_USART3_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* 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_USART2_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 */
printf("Hello guys");
    /* 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};
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};

  /** Configure the main internal regulator output voltage 
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  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_0) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART2|RCC_PERIPHCLK_USART3;
  PeriphClkInitStruct.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
  PeriphClkInitStruct.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @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 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 = 115200;
  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;
  huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  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 Ports Clock Enable */
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

}

/* USER CODE BEGIN 4 */
PUTCHAR_PROTOTYPE
{
  /* Place your implementation of fputc here */
  /* e.g. write a character to the USART3 and Loop until the end of transmission */
  HAL_UART_Transmit(&huart3, (uint8_t *)&ch, 1, 0xFFFF);

  return ch;
}
/* 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 */

  /* 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,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

En recopiant les deux bouts de code, le "Hello guys" ne s'affiche pas sur le terminal 

Je viens de m'apercevoir que lorsque je réalise une MAJ du firmware (Stm32CubeProgrammer), je n'arrive pas à me connecter à la carte car elle n'est plus détectée.

Cependant lorsque je la débranche puis la reconnecte sans refaire de maj je peux me connecter. Ensuite je vais sur STM32cubeide, je compile, mais lorsque je debug l'erreur suivante s'affiche:

Error in final launch sequence:

Failed to start GDB server

Failed to start GDB server

Error in initializing ST-LINK device.

Reason: (1) Failed to connect to device. Please check power and cabling to target.

Sauf que ma carte est bien connectée...

 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Quelques informations supplémentaires,

Lorsque je connecte ma carte sur mon ordi (câble USB vers USB mini), que j'ouvre et que je connecte ma carte sur STM32cubeprogrammer (sans faire de maj), que je compile sur Stm32cubeide le code (identique au code de mon dernier message) et que je debug j'ai l'erreur :

"STMicroelectronics ST-LINK GDB server. Version 5.5.0

Copyright (c) 2019, STMicroelectronics. All rights reserved.

Starting server with the following options:

        Persistent Mode            : Disabled

        Logging Level              : 1

        Listen Port Number         : 61234

        Status Refresh Delay       : 15s

        Verbose Mode               : Disabled

        SWD Debug                  : Enabled

        InitWhile                  : Enabled

Device connect error

Error in initializing ST-LINK device.

Reason: Failed to connect to device. Please check power and cabling to target."

Je suis perdu entre ces deux logiciels, savoir comment les gérer ensemble ... 

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Je vous remercie par avance,

-
Edité par UVess 30 juin 2020 à 10:45:59

UVess a écrit:

Je rappelle que j'utilise deux logiciels: STM32CubeProg et STM32CubeIDE (Ma carte STM32F767ZI est connectée via un câble USB vers USB mini)

Je lance STM32CubeProg, je réalise une MAJ puis la connecte sur ce même logiciel. Je lance STM32CubeIDE, compile le programme ci dessus. Mais une fois que j'appuie sur le bouton debug, l'erreur suivante survient:

Error in final launch sequence:
Failed to start GDB server
Failed to start GDB server
Error in initializing ST-LINK device.
Reason: (1) Failed to connect to device. Please check power and cabling to target.

Quand je n'utilise pas STM32CubeProg mais seulement IDE tt compile et debug seulement rien ne s'affiche sur la console.

Je ne sais pas où donner de la tête, j'aimerais vraiment pouvoir monter la manip de départ ...

Normalement tu devrais pouvoir n'utiliser que STM32CubeIDE pour programmer et debugger. 

Dans la configuration des broches (fichier .ioc), as tu activé l'option "Serial Wire" dans Pinout & Configuration / System Core / SYS / Debug ? Sans ça il semble que l'IDE ait du mal à reprogrammer la carte avant la session de débogage et surtout à activer le débogage, et le st-link affiche des erreurs bizarres parce qu'il n'arrive pas à se connecter à la puce principale.

Pour info, quand tu crées un nouveau projet, en sélectionnant la carte plutôt que la puce (onglet "Board Selector" plutôt que "MCU/MPU Selector" tout en haut de la fenêtre) , l'IDE te demande si tu veux initialiser les périphériques dans leurs modes par défaut, et ça active par défaut le port série du ST-Link et le "Serial Wire", donc peut-être que tout ça est déjà correctement configuré et que le problème est ailleurs.

Bonjour Alexis et merci pour tes réponses,

J'ai bel et bien configuré en serial wire,

Sur la datasheet suivante en page 60/61, j'ai vu qu'il fallait inclure ça:

https://www.st.com/resource/en/application_note/dm00354244-stm32-microcontroller-debug-toolbox-stmicroelectronics.pdf

Ce qui est équivalent à ce que l'on trouve dans l'exemple de l'uart printf.

Encore là, rien ne fonctionne.

Je suis également allé sur le compiler en ligne de Mbed, compilé et flashé un code qui permet d'afficher Hello WOrld.

J'ai vu sur putty Hello world. 

Cela confirme bien qu'il y a un pb au niveau du code....

Voila, voila, je pense que je ne vais plus utiliser le printf et trouver autrte chose comme une led qui clignotte pour tt faire fonctionner ..

En fait, je viens de voir que stm32cubeide n'a pas de terminal pour se connecter au port série: https://community.st.com/s/question/0D50X0000BNv7IQ/does-stm32cubeide-offer-a-serial-terminal-this-functionality-was-available-in-the-atollic-truestudio-product

Par contre, on peut utiliser la sortie SWO en activant "Trace Asynchronous SW" à la place de "Debug Wire", il y a plein de manipulations à faire dans l'IDE, mais au final, ça s'affiche dans l'IDE (juste dans une autre fenêtre "SWV ITM Data Console" qu'il faut ouvrir, et il y aura un bouton à cliquer à chaque session de débogage pour lancer la "capture" et donc l'affichage des messages): https://ralimtek.com/stm32_debugging/ (les instructions sont pour l'IDE Atollic, mais j'ai testé et ça fonctionne aussi pour STM32CubeIDE).

-
Edité par alexisdm 2 juillet 2020 à 15:23:48

Ah ok super, 

Mais du coup cela insinue qu'avec un terminal externe comme MobaXterm, Putty on ne peut pas lire les datas ?

Obligé de passer par ce fameux SW alors....

Afin de vérifier que les commandes s'exécutent j'utilise le clignotement des leds pour pouvoir avancer.

Seulement à un moment donné il faudra bien que j'arrive à lire ces données que j'envoie et que je stock.

EN tt cas merci pour tes recherches et ta réponse ^^.

-
Edité par UVess 7 juillet 2020 à 10:24:35