Dialogue entre STM32 et PC via USB ou UART

[Arkh3n]

Bonjour à tous,

Je suis en train de travailler sur un processeur STM32F103RBT6 sur la carte OLIMEXINO-STM32 : https://www.olimex.com/Products/Duin...IMEXINO-STM32/. J'utilise l'IDE CoIDE de CooCox.

Pour un projet, j'ai besoin de configurer un microcontrôleur pour envoyer et recevoir des trames CAN au sein d'un environnement automobile. J'ai notamment besoin de permettre à l'utilisateur de configurer facilement les trames sans avoir besoin de recompiler tout le code et/ou de sortir le microcontrôleur de son boitier waterproof. Mon encadrant m'a conseillé de permettre la configuration via USB (étant donné qu'il est facile de rendre "waterproof" un port USB et que les autres dispositifs semblables sur le marché utilisent l'USB). Le soucis, c'est que je n'ai jamais travaillé avec le protocole USB, et de ce que j'en ai lu, ça a l'air vachement casse tête...

Au tout début, je comptais trouver un moyen de donner un chemin à mon µC (C:/...) pour que celui-ci aille lire un fichier "config.txt" sur le PC et prenne les configs là dessus. Autant vous dire que ça n'a pas été un franc succès et qu'on ma rapidement déconseillé de creuser plus profond là dedans..

En me documentant et en farfouillant dans certains forums, il m'est venu l'idée de passer par le protocole UART (étant donné que je dois seulement envoyer des bits de configuration, la lenteur de l'UART p/r à l'USB ne me semble pas être un soucis). Afin de garder l'aspect "user friendly" de l'USB, je pensais ajouter un adaptateur USB vers UART que je mettrais dans le boîtier waterproof (le CP2102N par exemple : https://www.mouser.fr/ProductDetail/...gm0B6FZQu4VA== ), ça me permettrait de sortir en USB sur un PC tout en utilisant le protocole UART.

Pensez-vous que c'est une bonne idée compte tenu des contraintes matérielles auxquelles je fais face ?

Il me reste cependant quelques interrogations à propos du dialogue du PC vers le µC par UART. On m'a conseillé de créer un logiciel de serveur simplifié (un peu à la manière de PuTTY ou TeraTerm) dont le but serait d'envoyer les configurations placées dans un fichier "config.txt" créé au préalable. Le soucis c'est que je suis assez novice dans le développement logiciel, je ne sais pas du tout par où prendre le problème. En premier lieu, quel langage prendre (sachant que je connais le C, C++, Matlab (même si je ne pense pas que ça soit utile ici) et j'ai des notions de Python). A propos de la manière de faire, savez-vous un peu comment je pourrais demander à mon PC d'envoyer des infos via son port USB/COM ? J'avoue que cette partie reste un peu floue..

Si il vous manque quelconque information, n'hésitez pas à demander !

Merci d'avance pour votre aide !
-----

[lpt1com2]

Oui, je pense que ta solution tient la route, mais nécessite de faire un petit programme sur PC, et aussi sur le µC pour qu’il puisse savoir ce qu'il doit faire des données qu’il recevra. Pour le débit, je suppose que ton fichier de config ne pèse pas 100Mo (de toute façon, tu peux monter à 921600 b/s sauf erreur)

[Arkh3n]

Pour le µC, j'ai déjà utilisé l'UART sur des pic18f donc je pense que ça se fera bien.
J'ai cependant plus de problèmes à voir comment procéder pour la partie PC, comment je peux lui dire d'envoyer des infos sur un port COM ? C'est quelque chose que je n'ai jamais fait...

[DAUDET78]

Avec Hyperterminal, tu peux envoyer le contenu d'un fichier sur un port COM

[A voir en vidéo sur Futura]

[freepicbasic]

L'environnement arduino prend en compte les cartes STM32 Maple.
Peut être faut il programmer le boot , à moins qu'il y soit déjà .
ça simplifierait pas mal l'utilisation...


https://github.com/rogerclarkmelbour...i/Installation

[Ashura33]

Bonjour Arkh3n,

Je ne me suis pas encore suffisamment penché sur le sujet des STM32 pour pouvoir t'apporter une réponse complète. Cependant je vois que ta carte possède une interface USB native, dans STM32CubeMX on peut configurer l'USB en tant que "Communication Device Class (Virtual Port Com)", peut-être qu'il y a quelque chose à creuser de ce côté là.

Cordialement

[Arkh3n]

Salut tout le monde,

Premièrement, merci pour vos réponses.

Ensuite, on s'est concerté avec mes encadrants et on va rester sur l'utilisation UART et créer un interface en Windev (qui gère l'ouverture et le transfert d'infos par port COM).

Merci à tous !

[Arkh3n]

Salut tout le monde,

J'up ce sujet parce qu'il me vient un problème lorsque j'essaye de coder mon UART … Pour tester, j'ai relié le Rx et Tx de l'USART2 de la carte (ports D0 et D1) et j'appelle le code suivant :

int main(void)
{


    //Configurations
    Clk_Init();


        //Boucle infinie

      while(1)
      {

          InitUART(USART2);
          USART_send_byte(USART2, 0xBA);
          lecture = USART_read_byte(USART2);
           }
}

Je voulais vérifier la valeur de lecture dans le débugger, sauf que je me retrouve dans une boucle infinie dans la fonction USART_read_byte. Voici ce qui se trouve dans ces fonctions :

#include "includes.h"



void InitUART(USART_TypeDef* USARTx)
{

    USART_ClockInitTypeDef Clock_USART2;
    USART_InitTypeDef USART2_Definition;


/* VERIFIER QUE LES PARAMETRES PAR DEFAUT CORRESPONDENT AUX PARAMETRES REQUIS */

//UART GPIO Initialisation

    GPIO_InitTypeDef  GPIO_InitStructure;


      /* GPIO clock enable */

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_USART2, ENABLE);



      /* Configure USART pin: RX */
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_USART2_RX;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
      GPIO_Init(GPIO_USART2, &GPIO_InitStructure);

      /* Configure USART pin: TX */
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_USART2_TX;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_Init(GPIO_USART2, &GPIO_InitStructure);

      GPIO_PinRemapConfig(GPIO_Remapping_USART2 , ENABLE);

      /* USART Periph clock enable */
      RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);


//Activation UART

USART_Cmd(USARTx, ENABLE);                  // Je sélectionne l'UART "USART2" et je l'active.

//Definition Clock

USART_ClockStructInit(&Clock_USART2);       //On initialise la structure "Clock" de l'UART avec les valeurs par défaut
USART_ClockInit(USARTx, &Clock_USART2);     //On initialise la Clock grace aux paramètres définis dans la structure

//Definition Connection

USART_StructInit(&USART2_Definition);       //On initialise la structure "USART2" avec ses valeurs par défaut
USART2_Definition.USART_BaudRate = 57600;   //On change la valeur par défaut du Baudrate
USART_Init(USARTx, &USART2_Definition);     //On initialise l'UART grace aux paramètres définis dans la structure


/* DEFINITION DES INTERRUPT A RAJOUTER SI BESOIN ! */

//USART2->CR1 |= 0x20;                      //Active l'interrupt de RXNE


}



void USART_send_byte(USART_TypeDef* USARTx, uint16_t Data)
{

    while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE)==0);

    USART_SendData(USARTx, Data & 0x01FF);

}

uint16_t USART_read_byte(USART_TypeDef* USARTx)
{

    while(USART_GetFlagStatus(USARTx, USART_FLAG_RXNE)==0);

    return(USART_ReceiveData(USARTx));

}

Si vous avez des questions, n'hésitez pas … Parce que là je sèche … Je suis persuadé que c'est une connerie qui me manque, mais je m'arrache les cheveux sans trouver…

Merci d'avance !

PS : si il faut que je recréé un sujet, merci de me le dire !

[freepicbasic]

uint16_t USART_read_byte(USART_TypeDef* USARTx)
{

while(USART_GetFlagStatus(USAR Tx, USART_FLAG_RXNE)!=0)
return(USART_ReceiveData(USART x));
return(-1);

}

[Arkh3n]

Salut,

J'ai sûrement du mal exprimer ma question.
Le problème que j'ai ici c'est que mon flag RXNE (RX not empty) ne se met jamais à 1 (il n'est donc jamais prêt à être lu)... Et je n'arrive pas à comprendre pourquoi ...

[antek]

Tu as regardé la doc de ton STM32 ? un lien ?

[Arkh3n]

yes, j'ai bien lu la DOC, le seul truc qui me pose problème c'est le fait que les GPIO ne sont pas clairement inscrits ... J'ai du farfouiller dans l'utilitaire CubeMX pour m'assurer que ça soit les bons pour l'USART2 ...

Pour la doc du STM32 voici : http://www.st.com/content/ccc/resour...CD00171190.pdf

et la doc de la carte Olimex : https://www.olimex.com/Products/Duin...XINO-STM32.pdf

[antek]

ça veut dire qu'il n'y a rien dans le registre de réception
Tu peux vérifier si un message est envoyé par le PC (avec un oscilloscope ou un analyseur) ?

[Arkh3n]

C'est là où le bât blesse, je n'ai ni oscilloscope ni analyseur sous la main ... Donc je n'arrive pas à savoir si l'erreur vient de l'envoi, ou de la réception (flag mal configuré, pinout pas bon ...), je pensais arriver à lire les registres via le débugger, mais non ..

[naru2to]

A défaut d'avoir un oscillo, pour de l'UART, un module FT232 ou équivalent ça coûte pas grand chose et ça permettrait de debuger simplement (une fois que l'UART fonctionne tu peux t'en servir pour envoyer tout un tas d'information!)

[Arkh3n]

J'ai ça : https://www.mouser.fr/ProductDetail/...gm0B6FZQu4VA==
un CP2102N (qui me semble pas mal équivalent à un FT232 !), par contre j'avoue avoir du mal à voir comment ça peut me permettre de debuger simplement .. :/

[naru2to]

Tu relies le STM32 et le CP2102 de cette façon :
STM32_Tx <---> CP2102_Rx
STM32_Rx <---> CP2102_Tx

Sur le STM32 essaie de faire un programme qui envoie les deux caractères 'A' et '\n' (le '\n' est important car c'est le caractère de fin de trame)
Ensuite tu ouvres un terminal avec le bon port, le bon baudrate, et surtout le bon caractère de terminaison ('\n')

Si l'envoi de caractère fonctionne tu devrais voir des 'A' qui apparaissent sur le terminal.

[Arkh3n]

J'ai essayé et rien ne s'affiche..

Par contre, je n'ai pas trouvé comment définir le bon caractère de terminaison sur les 2 terminaux que j'ai utilisé (PuTTY et Hyperterminal). Juste pour être sûr, j'envoie bien 3 octets ? le premier avec "A" (0x41), le second avec "\" (0x5c) et le dernier avec "n" (0x6e) ?

[Arkh3n]

Pardon, jsuis trop con. \n c'est 0x0a ...

J'ai modifié mon code et j'envoi donc mes 2 octets 0x41 et 0x0a, mais rien ne se passe :'(

[naru2to]

Non, le '\n' est en un seul caractère.
Et pour envoyer un caractère on utilise ' et pour une chaine de caractères on utilise " :
USART_sendByte('\n');
USART_sendString("hello!\n");

Dans le doute pour le terminal, tu peux essayer en envoyant '\r' ou '\r' suivi de '\n'

[Arkh3n]

bon bah j'ai essayé (en mettant direct en hexa pour pas me planter sur ' et " ^^), avec \r et \n, mais rien ne se passe..

Le soucis doit donc venir de mon send byte (ou alors du terminal que j'ai mal configuré, mais je ne pense pas, tous les terminaux permettent de recevoir des octets, non ?)

[naru2to]

Je vois que dans les fonctions il y a des while pour attente d'évènement, notamment la réception de caractère... C'est possible que le programme bloque quelque part, est-ce qu'il y a un timer ou une tempo avec une LED qui clignote? ça permettrait de vérifier que le programme est pas bloqué dans une des boucles.

De plus il faudrait enlever la partie réception de caractère, et tenter de transmettre sans interruption en passant directement par le registre de transmission.

[Arkh3n]

l'endroit où ça bloque quand je vais pas à pas avec le débuger c'est ici :

uint16_t USART_read_byte(USART_TypeDef* USARTx)
{

	while(USART_GetFlagStatus(USARTx, USART_FLAG_RXNE)==0);

	return(USART_ReceiveData(USARTx));

	//return(-1);

}

au niveau du while, ça mouline sans rien faire, mais pour tout ce qui est envoi etc, aucun blocage.

Pour faire les essais avec les terminaux j'ai changé mon main comme ça :

while(1)
	  {

		  USART_send_byte(USART2, 0x41);
		  USART_send_byte(USART2, 0x0a);

	  }

(les init sont avant le while(1) ça n'a pas changé).