Passage d'adresse de variable entre plusieurs fonctions.

**dje8269** · 06/04/2025, 14h44

Bonjour à tous,

Actuellement je travaille sur la mise en œuvre de module radio LLCC68 de chez Semtech.
Une librairie à été créer pour cette puce radio .

La seule chose que demande cette librairie c'est de créer deux fonctions afin de pouvoir l'utiliser avec son propre équipement. Chez moi ce sera des STM32 nucleo board.
Les deux fonctions servent à envoyer des commandes SPI et à lire des registres.

J'ai un problème de compréhension pour créer ma fonction de lecture. en effet les valeurs retournés ne sont pas celle attendues. donc ma fonction ne fait pas le taf correctement.

Voici ma fonction qu'il faut réparée dans mon main.c

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
//---------------------------   HAL_READ   ------------------------------
llcc68_hal_status_t llcc68_hal_read( const void* context, const uint8_t* command, const uint16_t command_length,
                                     uint8_t* data, const uint16_t data_length )
{
	uint32_t Length = command_length + data_length;
	uint8_t Tx_SPI[Length];
 
	for (uint8_t i = 0; i<command_length ; ++i)
	{
		Tx_SPI[i]= command[i];
	}
	for (uint8_t i = 0; i<data_length ; ++i)
	{
		Tx_SPI[i+command_length]= data[i];
	}
 
	while (HAL_GPIO_ReadPin(BUSY_GPIO_Port, BUSY_Pin)==1){__NOP();}; // attente du busy
 
	HAL_GPIO_WritePin(NSS_GPIO_Port, NSS_Pin, GPIO_PIN_RESET);
		if (HAL_SPI_TransmitReceive(&hspi1, Tx_SPI,  data, Length, 100) != HAL_OK)
		{
			HAL_GPIO_WritePin(NSS_GPIO_Port, NSS_Pin, GPIO_PIN_SET);
			return LLCC68_HAL_STATUS_ERROR;
		}
	HAL_GPIO_WritePin(NSS_GPIO_Port, NSS_Pin, GPIO_PIN_SET);
 
	return LLCC68_HAL_STATUS_OK ;
}

Donc la librairie Semtech fais appelle à cette fonction pour elle même fonctionner. Elle est donc primordiale. Le problème c'est que la librairie Semtech fait des aller retour qui me perde complétement entre leurs fonctions et mes fonctions.

C'est parti !

Dans mon main.c j’appelle cette fonction de la librairie :

Code :

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

1
2
llcc68_pkt_params_lora_t pkt_params = {0x0012, LLCC68_LORA_PKT_EXPLICIT, 0x09, false, false};  // P.83 - 86
	llcc68_set_lora_pkt_params(context, &pkt_params);

voici la fonction de Semtech qui reçoit les arguments:

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
llcc68_status_t llcc68_set_lora_pkt_params( const void* context, const llcc68_pkt_params_lora_t* params )
{
    const uint8_t buf[LLCC68_SIZE_SET_PKT_PARAMS_LORA] = {
        LLCC68_SET_PKT_PARAMS,
        ( uint8_t )( params->preamble_len_in_symb >> 8 ),
        ( uint8_t )( params->preamble_len_in_symb >> 0 ),
        ( uint8_t )( params->header_type ),
        params->pld_len_in_bytes,
        ( uint8_t )( params->crc_is_on ? 1 : 0 ),
        ( uint8_t )( params->invert_iq_is_on ? 1 : 0 ),
    };
 
    llcc68_status_t status =
        ( llcc68_status_t ) llcc68_hal_write( context, buf, LLCC68_SIZE_SET_PKT_PARAMS_LORA, 0, 0 );
 
    // WORKAROUND - Optimizing the Inverted IQ Operation, see datasheet DS_LLCC68_V1.0 §15.4
    if( status == LLCC68_STATUS_OK )
    {
        uint8_t reg_value = 0;
 
        status = llcc68_read_register( context, LLCC68_REG_IQ_POLARITY, &reg_value, 1 );
        if( status == LLCC68_STATUS_OK )
        {
            if( params->invert_iq_is_on == true )
            {
                reg_value &= ~( 1 << 2 );  // Bit 2 set to 0 when using inverted IQ polarity
            }
            else
            {
                reg_value |= ( 1 << 2 );  // Bit 2 set to 1 when using standard IQ polarity
            }
            status = llcc68_write_register( context, LLCC68_REG_IQ_POLARITY, &reg_value, 1 );
        }
    }
    // WORKAROUND END
 
    return status;
}

Cette fonction appelle une autre fonction de la librairie Semtech "llcc68_read_register":

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
llcc68_status_t llcc68_read_register( const void* context, const uint16_t address, uint8_t* buffer, const uint8_t size )
{
    const uint8_t buf[LLCC68_SIZE_READ_REGISTER] = {
        LLCC68_READ_REGISTER,
        ( uint8_t )( address >> 8 ),
        ( uint8_t )( address >> 0 ),
        LLCC68_NOP,
    };
 
    return ( llcc68_status_t ) llcc68_hal_read( context, buf, LLCC68_SIZE_READ_REGISTER, buffer, size );
}

Cette fonction fait appelle à ma propre fonction du début " llcc68_hal_read" .

Avec toutes ces passages d'arguments je ne retrouve plus mes petits.

Le problème ce situe au niveau de la variable "reg_value" qui n'est pas bien lu par ma fonction. Du coup la modification de cette variable est foireuse et le résultat aussi.
Le but est de lire la valeur une valeur de registre, la stockée dans la variable reg_value, d'effectuer une operation ( mettre le bit 2 à 1) et de réécrire la valeur dans le registre.

Du coup comment dois-je ecrire cette ligne dans ma fonction :

Code :

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

(HAL_SPI_TransmitReceive(&hspi1, Tx_SPI,  data, Length, 100) != HAL_OK)

Je pense que le problème vient de l'écriture de data ? dois-je mettre un pointeur ?

Merci de m'avoir lu et de m'aider si vous avez compris ! lol

**dje8269** · 06/04/2025, 17h12

Re,

Je me réponds à ma moi même, car en travaillant sur mon probléme j'ai une explication mais la mise en œuvre de la solution, n'est pas évidente pour mon niveau.

en fait l'erreur viens du fait que dans la transmission SPI. les 4 premiers octets ne font pas partie de la réponse. ce sont des octets sans intérêt car des commandes.
La réponse SPI à prendre en compte arrive seulement après les 4 premiers octets.

Il faut donc que j'écrive dans le pointeur *data seulement à pertir du 5ieme octets

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
//---------------------------   HAL_READ   ------------------------------
llcc68_hal_status_t llcc68_hal_read( const void* context, const uint8_t* command, const uint16_t command_length,
                                     uint8_t* data, const uint16_t data_length )
{
	uint32_t Length = command_length + data_length;
	uint8_t Rx_SPI[data_length];
	uint8_t Tx_SPI[Length];
 
	for (uint8_t i = 0; i<command_length ; ++i)
	{
		Tx_SPI[i]= command[i];
	}
	for (uint8_t i = 0; i<data_length ; ++i)
	{
		Tx_SPI[i+command_length]= Rx_SPI[i];
	}
 
	while (HAL_GPIO_ReadPin(BUSY_GPIO_Port, BUSY_Pin)==1){__NOP();}; // attente du busy
 
	HAL_GPIO_WritePin(NSS_GPIO_Port, NSS_Pin, GPIO_PIN_RESET);
		if (HAL_SPI_TransmitReceive(&hspi1, Tx_SPI,  Rx_SPI, Length, 100) != HAL_OK)
		{
			HAL_GPIO_WritePin(NSS_GPIO_Port, NSS_Pin, GPIO_PIN_SET);
			return LLCC68_HAL_STATUS_ERROR;
		}
	HAL_GPIO_WritePin(NSS_GPIO_Port, NSS_Pin, GPIO_PIN_SET);
 
	for (uint8_t i = 0; i<data_length ; ++i)
	{
		data[i]= Rx_SPI[i+command_length];
	}
 
	return LLCC68_HAL_STATUS_OK ;
}

J'ai écrit cela ça à l'air de fonctionner pour mon exemple précis, mais je ne le sens pas trop . Pouvez vous me confirmer ?

Passage d'adresse de variable entre plusieurs fonctions.

C

Discussions similaires

Partager

Partager