Discussion :

[tengalice49]

Bonjour, je possede le module Sigfox LPWAN suivant : https://partners.sigfox.com/products/lpwan-sigfox-node

Lorsque je connecte mon module Sigfox avec un convertisseur USB a UART de ce type: http://fr.farnell.com/ftdi/usb-rs485...%C3%A0%20RS485, je peux envoyer des commandes AT (liste page 9: https://www.lpwan.cz/LPWAN_sigfox_node_datasheet_v1.pdf) et je vois que mes commandes sont bien recues.

En effet, lorsque j'entre par exemple la commande

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

AT$SF=0506

dans un terminal connecte a l'uart, j'obtiens une reponse et je peux voir sur le site de Sigfox que mon message a bien ete envoye:



Maintenant j'aimerais bien "automatiser" ce systeme et l'integrer dans un code pour pouvoir envoyer regulierement des donnees.

J'ai donc le code suivant qui est tres simple:
J'initialise les Uart et j'ai une fonction qui permet d'envoyer les printf sur l'uart:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
  //Initialisation de l'UART2 à la vitesse de 115200 bauds/secondes
  UART_init(UART5_ID,9600);	//GPS
  UART_init(UART2_ID,9600);	//SIGFOX

  //"Indique que les printf sortent vers le périphérique UART2."
  SYS_set_std_usart(UART2_ID, UART2_ID, UART2_ID);

Voici la fonction qui ecrit une commande AT:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
char str[20];
void measure(void){
	sprintf(str,"AT$SF=A10A\n");
	printf(str);
	HAL_Delay(3000); //3000ms
}

J'appelle cette fonction dans la boucle infinie du main:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
  while (1)
{

	  measure();
}

Apres avoir fait cela, je vois bien que mes commandes sont envoyees reguilierement (toutes les 3s) dans l'uart:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
AT$SF=A10A<LF>
AT$SF=A10A<LF>
AT$SF=A10A<LF>
AT$SF=A10A<LF>
AT$SF=A10A<LF>
AT$SF=A10A<LF>
AT$SF=A10A<LF>
AT$SF=A10A<LF>
AT$SF=A10A<LF>

Cependant, elles ne sont pas envoyees sur le site de Sigfox comme cela le faisait avec l'adaptateur usb a uart.
Comment faire pour que les commandes AT que j'ecris sur mon programme soient envoyees via l'uart a mon module Sigfox ?

Merci pour votre aide

[Vincent PETIT]

Salut,
Si tu veux des réponses il faut que tu ailles plus loin dans tes explications et il faut que tu facilites le travail de compréhension des gens qui te répondent

- Tu donnes le lien de ton convertisseur USB/RS485, très bien !
- Tu donnes le lien du module Sigfox mais là je lis qu'il faut s'enregistrer pour voir la doc. En cherchant un peu on voit que le lien est ici https://www.lpwan.cz/LPWAN_sigfox_node_datasheet_v1.pdf mais je peux te dire avec certitude que tu as perdu quasiment tous ceux qui voulaient t'aider mais qui ne sont pas prêt à chercher après les infos.


Toute de suite, je vois un gros problème avant même de regarder le code.
Le module Sigfox est prévu pour être connecté a un UART logique, de plus il s'alimente en +3,3V et ton adaptateur USB délivre du +5V et un signal RS485. On ne peut pas connecter du RS485 sur un UART directement et encore moins si les tensions sont différentes.



Soit tu es à la limite de tout cramer avec l'adaptateur et c'est un coup de chance incroyable si ça a fonctionné.
Soit tu as peut être donné la mauvaise doc sur l'adaptateur USB ce qui explique pourquoi je ne comprends pas.


A+

[tengalice49]

Salut Vincent, merci d'avoir pris le temps de chercher ce que j'ai mal explique et de m'avoir repondu. Je vais essayer de recommencer en etant plus clair et plus precis.

Le lien du convertisseur que j'ai mis n'est pas le bon car je ne sais pas vraiment de quel convertisseur il s'agit puisqu'il m'a ete donne tel quel. Voici une photo de ce convertisseur:

Il ressemble tres fortement a ce produit: Lien aliexpress

Lorsque je connecte ce convertisseur a mon module Sigfox LPWAN (dont voici la datasheet: Datasheet module Sigfox), j'arrive a envoyer des commandes AT et tout fonctionne tres bien comme je l'ai explique dans mon precedant post.

Maintenant je voudrais faire fonctionner ce module Sigfox avec ma carte STM32L152RE via l'UART.

Voici le code d'initialisation de l'uart:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
void UART_init(uart_id_e uart_id, uint32_t baudrate)
{
	assert(baudrate > 1000);
	assert(uart_id < UART_ID_NB);

	buffer_rx_read_index[uart_id] = 0;
	buffer_rx_write_index[uart_id] = 0;
	buffer_rx_data_ready[uart_id] = FALSE;
	/* USARTx configured as follow:
		- Word Length = 8 Bits
		- One Stop Bit
		- No parity
		- Hardware flow control disabled (RTS and CTS signals)
		- Receive and transmit enabled
		- OverSampling: enable
	*/
	UART_HandleStructure[uart_id].Instance = (USART_TypeDef*)instance_array[uart_id];
	UART_HandleStructure[uart_id].Init.BaudRate = baudrate;
	UART_HandleStructure[uart_id].Init.WordLength = UART_WORDLENGTH_8B;//
	UART_HandleStructure[uart_id].Init.StopBits = UART_STOPBITS_1;//
	UART_HandleStructure[uart_id].Init.Parity = UART_PARITY_NONE;//
	UART_HandleStructure[uart_id].Init.HwFlowCtl = UART_HWCONTROL_NONE;//
	UART_HandleStructure[uart_id].Init.Mode = UART_MODE_TX_RX;//
	UART_HandleStructure[uart_id].Init.OverSampling = UART_OVERSAMPLING_16;//

	/*On applique les parametres d'initialisation ci-dessus */
	HAL_UART_Init(&UART_HandleStructure[uart_id]);
	
	/*Activation de l'UART */
	__HAL_UART_ENABLE(&UART_HandleStructure[uart_id]);

	// On fixe les priorités des interruptions de l'usart PreemptionPriority = 0, SubPriority = 1 et on autorise les interruptions
	HAL_NVIC_SetPriority(nvic_irq_array[uart_id] , 1, 1);
	HAL_NVIC_EnableIRQ(nvic_irq_array[uart_id]);
	HAL_UART_Receive_IT(&UART_HandleStructure[uart_id],&buffer_rx[uart_id][buffer_rx_write_index[uart_id]],1);	//Activation de la réception d'un caractère

	//Config LibC: no buffering
	setvbuf(stdout, NULL, _IONBF, 0 );
	setvbuf(stderr, NULL, _IONBF, 0 );
	setvbuf(stdin, NULL, _IONBF, 0 );
}

Que j'appelle dans mon main:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

UART_init(UART2_ID,9600);	//SIGFOX

Ensuite je redirige les printf vers cet uart (toujours dans le main):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
//"Indique que les printf sortent vers le périphérique UART2."
  SYS_set_std_usart(UART2_ID, UART2_ID, UART2_ID);

Et dans ma boucle infinie du main j'appelle cette fonction pour tester l'envoie d'une commande AT:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
char str[20];
void measure(void){
	sprintf(str,"AT$SF=A10A\n");
	printf(str);
	HAL_Delay(3000);
}

Le probleme c'est que au lieu "d'effectuer" cette commande et donc d'envoyer le message "A10A" sur le site de Sigfox (qui recupere tous les messages envoyes), j'ai l'mippression que mon code ne fait que "ecrire" sur l'uart et je peux donc "lire" les commandes que j'envoie mais le module ne me renvoie aucune reponse.

En esperant avoir ete plus clair

[Vincent PETIT]

Montre moi comment tu as câblé tout ça ensuite trouve la description de SYS_set_std_usart pour que je vois ce qu'on met en paramètre dedans car j'ai l'impression que la redirection de stdout vers l'UART ne fonctionne pas.

[tengalice49]

En ce qui concerne le cablage, j'ai relie les broches 3V3 et Gnd du module Sigfox aux 3V3 et Gnd de la STM. J'ai relie le Tx du module au Rx de la STM et inversement comme cela:


PA2 et PA3 sont bien definis je pense:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//au dessus il y a le if pour UART5
else if(huart->Instance == USART2)
	{
		#ifdef UART2_ON_PA2_PA3
		/* USER CODE BEGIN USART2_MspInit 0 */

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

		    /**USART2 GPIO Configuration
		    PA2     ------> USART2_TX
		    PA3     ------> USART2_RX
		    */
		    GPIO_InitStruct.Pin = TX_Sigfox_Pin|RX_Sigfox_Pin;
		    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
		    GPIO_InitStruct.Pull = GPIO_PULLUP;
		    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
		    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
		    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

		  /* USER CODE BEGIN USART2_MspInit 1 */

		  /* USER CODE END USART2_MspInit 1 */
		#endif

Avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#define TX_Sigfox_Pin GPIO_PIN_2
#define TX_Sigfox_GPIO_Port GPIOA
#define RX_Sigfox_Pin GPIO_PIN_3
#define RX_Sigfox_GPIO_Port GPIOA

trouve la description de SYS_set_std_usart

Pour etre honnete j'ai recupere cette fonction sur le code d'un de mes profs, et je n'y comprends pas grand chose mais je sais que dans la pratique, tous les printf de mon code sont ecrit dans l'uart, cependant ils sont ecrit sous forme de chaine de caractere et donc quand je veux envoyer une commande AT a mon module ce n'est surement pas cette fonction que je dois utiliser mais je ne sais pas comment faire autrement.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void SYS_set_std_usart(uart_id_e in, uart_id_e out, uart_id_e err)
{
	stdin_usart = in;
	stdout_usart = out;
	stderr_usart = err;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef STDOUT_USART
	#define DEFAULT_STDOUT_USART UART1_ID
#endif

#ifndef STDERR_USART
	#define DEFAULT_STDERR_USART UART1_ID
#endif

#ifndef STDIN_USART
	#define DEFAULT_STDIN_USART UART1_ID
#endif

static uart_id_e stdout_usart = DEFAULT_STDOUT_USART;
static uart_id_e stderr_usart = DEFAULT_STDERR_USART;
static uart_id_e stdin_usart 	= DEFAULT_STDIN_USART;

Voici le fichier complet contenant cette fonction car j'avoue que je ne sais pas trop ou regarder : https://pastebin.com/U8gjtHhj


EDIT 1: Je peux eventuellement utiliser ces fonctions qui m'ont l'air beaucoup mieux adaptees a ma situation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
	uint8_t UART_getc(uart_id_e uart_id);

	/**
	 * @brief	Envoi un caractere sur l'USARTx. Fonction BLOCANTE si un caractere est deja en cours d'envoi.
	 * @func 	void UART_putc(UART_HandleTypeDef * UART_Handle, char c)
	 * @param	c : le caractere a envoyer
	 * @param	USARTx : USART1, USART2 ou USART6
	 */
	void UART_putc(uart_id_e uart_id, uint8_t c);

	/**
	 * @brief	Envoi une chaine de caractere sur l'USARTx. Fonction BLOCANTE si un caractere est deja en cours d'envoi.
	 * @func 	void UART_putc(UART_HandleTypeDef * UART_Handle, char c)
	 * @param	str : la chaine de caractère Ã* envoyer
	 * @param	USARTx : USART1, USART2 ou USART6
	 */
	void UART_puts(uart_id_e uart_id, uint8_t * str, uint8_t len);

	/*
	 * @brief	Fonction permettant de savoir si le buffer de l'UART demand� est vide ou non.
	 * @ret		Retourne VRAI si un ou des caractères sont disponibles dans le buffer.
	 * @ret		Retourne FAUX si aucun caractère n'est disponible dans le buffer (le buffer est vide)
	 * @param	uart_id est le num�ro de l'UART concerné :	UART1_ID, UART2_ID, UART3_ID
	 */

Pour le moment j'ai ecris cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
char str[20];
void measure(void){
	sprintf(str,"AT$SF=A10A\n");
	UART_puts(UART2_ID, str, sizeof(str));
	HAL_Delay(3000);
}

Mais j'obtiens une erreur car j'initialise un char et il me demande un uint8_t je sais jamais comment faire dans ces cas la :/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
../Src/main.c: In function 'measure':
../Src/main.c:240:22: warning: pointer targets in passing argument 2 of 'UART_puts' differ in signedness [-Wpointer-sign]
  UART_puts(UART2_ID, str, sizeof(str));
                      ^~~

EDIT 2: J'ai une fonction UART_puts qui fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
char str[12];
void measure(void){
	sprintf(str,"AT$SF=A10A\n");
	UART_puts(UART2_ID, (uint8_t*)str, sizeof(str));
	HAL_Delay(3000);
}

Cependant, j'ai un espace qui se fait juste avant le "AT", je me demande si l'erreur ne viendrait pas de la etant donne que les commandes AT sont sensibles au caractere pres.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
05/06/2018 14:45:56.404 [RX] - <NUL>AT$SF=A10A<LF>
<NUL>AT$SF=A10A<LF>
<NUL>AT$SF=A10A<LF>
<NUL>AT$SF=A10A<LF>

[Vincent PETIT]

Ok pour le câblage.

PA2 et PA3 sont bien definis je pense:

Oui, d'après ce que je vois.

Pour etre honnete j'ai recupere cette fonction sur le code d'un de mes profs, et je n'y comprends pas grand chose

Rassure toi c'est normal (voir en bas de mon message *)
Attention j'ai modifier les directives #define blablabla UART1_ID en #define blablabla UART2_ID car tu sembles utiliser l'UART 2

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void SYS_set_std_usart(uart_id_e in, uart_id_e out, uart_id_e err)
{
	stdin_usart = in;
	stdout_usart = out;
	stderr_usart = err;
}
 
......
 
#ifndef STDOUT_USART
	//#define DEFAULT_STDOUT_USART UART1_ID
#define DEFAULT_STDOUT_USART UART2_ID
#endif
 
#ifndef STDERR_USART
	//#define DEFAULT_STDERR_USART UART1_ID
#define DEFAULT_STDERR_USART UART2_ID
#endif
 
#ifndef STDIN_USART
	//#define DEFAULT_STDIN_USART UART1_ID
#define DEFAULT_STDERR_USART UART2_ID
#endif
 
static uart_id_e stdout_usart = DEFAULT_STDOUT_USART;
static uart_id_e stderr_usart = DEFAULT_STDERR_USART;
static uart_id_e stdin_usart 	= DEFAULT_STDIN_USART;

Tu peux refaire un essai ?

Je peux eventuellement utiliser ces fonctions qui m'ont l'air beaucoup mieux adaptees a ma situation:
uint8_t UART_getc(uart_id_e uart_id); void UART_putc(uart_id_e uart_id, uint8_t c); void UART_puts(uart_id_e uart_id, uint8_t * str, uint8_t len);

Et c'était une très bonne idée !




* L'encapsulation totale ou à outrance sur un microcontrôleur t'emmène inévitablement dans le mur car à chaque réglage des registres et à moins qu'il ne s'agisse de ton code tu es obligé de tout détricoter, toutes les couches encapsulées, pour comprendre tout le code et ce que ça fait afin de faire tes réglages. De plus, étant donné qu'un micro peut faire plein de truc différent, la couche HAL devient forcément très très lourde car elle doit prévoir tous les réglages possible. A coup sur tu aussi vite fait de tout réécrire car tu iras bien plus vite. Tandis que pour un programme PC c'est terriblement efficace (c'est normal car tu ne configures rien dans le processeur, l'OS s'en est chargé, et tout est standardisé donc pas besoin de prévoir tous les trucs tordus, possibles et imaginables.)

[tengalice49]

Salut,

#ifndef STDIN_USART
//#define DEFAULT_STDIN_USART UART1_ID
#define DEFAULT_STDERR_USART UART2_ID
#endif

Je suppose que tu voulais ecrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#ifndef STDIN_USART
    //#define DEFAULT_STDIN_USART UART1_ID
#define DEFAULT_STDIN_USART UART2_ID
#endif

Du coup en faisant comme cela j'ai toujours le meme probleme. A noter que sur Tera Term VT il m'ecrit mes commandes en diagonales je sais pas si c'est normal mais etant donne que les commandes sont lues au caractere pres j'ai peur qu'il y ait un espace ou un "Entree" qui derange:



En ce qui concerne les autres fonctions qui pourraient fonctionner, j'ai ecris cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
char str[12];
void measure(void){
	sprintf(str,"AT$SF=A10A\n");
	//printf(str);
	UART_puts(UART2_ID, (uint8_t*)str, sizeof(str));
	HAL_Delay(3000);
}

Encore une fois cela ne fonctionne pas, j'ai un petit caractere qui se place avant le debut du "AT" je ne sais pas d'ou il vient:


EDIT: En modifiant cette ligne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

UART_puts(UART2_ID, (uint8_t*)str, sizeof(str));

Par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

UART_puts(UART2_ID, (uint8_t*)str, sizeof(str)-1);

J'obtiens quelque chose de semblable a la fonction SYS_set_std_usart:

[tengalice49]

Bonjour, j'ai finalement regle mon probleme en changeant d'uart, je ne sais pas pourquoi mais apparemment les broches de l'uart doivent etre "bloquees" car a l'oscillo elles ne renvoyaient aucun signal (0V).

Du coup ce code fonctionne bien, il faut simplement bien initialiser l'uart:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
char str[11];
void sigfox_send_test(void){
	sprintf(str,"AT$SF=4444\r");
	//printf(str);
	UART_puts(UART3_ID, (uint8_t*)str, sizeof(str));
	HAL_Delay(10000);
}

Merci beaucoup Vincent pour ton aide