Discussion :

[pegase.90]

Bonjour,

Sur un système embarqué à base de µcontroleur, je veux écrire des données dans un buffer mais uniquement une données sur deux.
Ces données proviennent d'un accéléromètre via le bus SPI. Je ne veux sauvegarder dans mon buffer qu'une donnée sur deux. Je me suis arrangé pour toujours avoir un nombre de données paires en provenance de l'accéléromètre.
J'ai déja écrit un petit morceaux de code mais je me demandais s'il y avait une manière plus élégante et surtout plus rapide en temps processeur pour faire ceci.

Voici le code:

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
 
 
for(i=0; i< NbrAcc; i++){	
	X[i] = spi_transfer(0x00)<<8; 		//X_MSB byte
	X[i] |= spi_transfer(0x00);			//X_LSB byte
	Y[i] = spi_transfer(0x00)<<8; 		//Y_MSB byte
	Y[i] |= spi_transfer(0x00);			//Y_LSB byte
	Z[i] = spi_transfer(0x00)<<8; 		//Z_MSB byte
	Z[i] |= spi_transfer(0x00);			//Z_LSB byte	
 
	if(i%2==0){	
	buffer_writeDouble(X[i]);		//Store data 1/2 to buffer
	buffer_writeDouble(Y[i]);
	buffer_writeDouble(Z[i]);
	}	
}

Merci.

[ram-0000]

Je ne sais pas comment est implémentée l'opération modulo par ton compilateur mais normallement, le modulo est le reste de la division entière et donc dans le pire des cas, le compilateur fait une division pour évaluer le modulo.

Pour y gagner (peut être ?) un peu et vu que seul le résultat pair/impair t'intéresse, tu pourrais aussi faire un test sur le bit de poid faible de ta variable et remplacer

Code :

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

if(i%2==0)

par :

Code :

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

1
2
3
4
5
6
7
8
if( (i & 1) == 0)
{
   // le nombre i est pair
}
else
{
   // le nombre i est impair
}

[Invité(e)]

Bonjour,

On peut aussi faire des boucles avec un incrément de 2 :

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
for(i = 1; i < NbrAcc; i += 2){	
	/* i est toujours impair dans cette boucle */
	X[i] = spi_transfer(0x00)<<8; 		
	X[i] |= spi_transfer(0x00);			
	Y[i] = spi_transfer(0x00)<<8; 		
	Y[i] |= spi_transfer(0x00);			
	Z[i] = spi_transfer(0x00)<<8; 		
	Z[i] |= spi_transfer(0x00);			

	X[i-1] = spi_transfer(0x00)<<8; 		
	X[i-1] |= spi_transfer(0x00);			
	Y[i-1] = spi_transfer(0x00)<<8; 		
	Y[i-1] |= spi_transfer(0x00);			
	Z[i-1] = spi_transfer(0x00)<<8; 		
	Z[i-1] |= spi_transfer(0x00);			
		

	buffer_writeDouble(X[i-1]);		//Store data 1/2 to buffer
	buffer_writeDouble(Y[i-1]);
	buffer_writeDouble(Z[i-1]);

}

[pfeuh]

Salut,

Si le but est vraiment l'économie de cycles-machine, tu peux éviter les variables temporaires sur la pile. On gagne en vitesse, mais on perd en lisibilité et factorisation du code. On peut aussi remplacer la boucle for par un while(NbrAcc--), mais attention à la post décrémentation qui inverse la parité.

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
for(i=0; i< NbrAcc; i++)
{
    if( (i & 1) == 0)
    {
        buffer_writeDouble((spi_transfer(0x00)<<8) + spi_transfer(0x00));//Store data 1/2 to buffer
        buffer_writeDouble((spi_transfer(0x00)<<8) + spi_transfer(0x00));
        buffer_writeDouble((spi_transfer(0x00)<<8) + spi_transfer(0x00));
    }
    else
    {
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
    }
}

A+

Pfeuh

[pegase.90]

Merci à tous de vos solutions. J'ai essayé plusieurs d'entre elles mais cela ne change pas le temps. Je reste donc à 8ms pour ce traitement. Ce qui est encore tout à fait acceptable pour mon application.

[souviron34]

Merci à tous de vos solutions. J'ai essayé plusieurs d'entre elles mais cela ne change pas le temps. Je reste donc à 8ms pour ce traitement. Ce qui est encore tout à fait acceptable pour mon application.

Là tu calcules et tu fais 3 shitfts, 3 OU, et 6 assignations plus un test inutiles)...

Moi je ferais (si j'ai bien compris qu'il te faut lire à tout coup) :

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
for(i=0; i< NbrAcc; i=i+2){	
	X[i] = spi_transfer(0x00)<<8; 		//X_MSB byte
	X[i] |= spi_transfer(0x00);			//X_LSB byte
	Y[i] = spi_transfer(0x00)<<8; 		//Y_MSB byte
	Y[i] |= spi_transfer(0x00);			//Y_LSB byte
	Z[i] = spi_transfer(0x00)<<8; 		//Z_MSB byte
	Z[i] |= spi_transfer(0x00);			//Z_LSB byte	
 
	buffer_writeDouble(X[i]);		//Store data 1/2 to buffer
	buffer_writeDouble(Y[i]);
	buffer_writeDouble(Z[i]);
 
	j = spi_transfer(0x00);
	j = spi_transfer(0x00);
	j = spi_transfer(0x00);
	j = spi_transfer(0x00);
	j = spi_transfer(0x00);
	j = spi_transfer(0x00);
	}	
}

A moins que cel soit voulu et que tu veuilles tout stocker, mais à ce compte-là tu remets des X[i+1] directement en dessous.

Cependant le plus important est ci-dessous :

Une autre optimisation est de faire référence à des pointeurs sur X, Y, et Z.

Là, tu fais calculer entre 2 et 3 fois l'adresse à chaque fois.. une pour la première assignation, une pour le OU ligne suivante, une pour l'écriture

Soit xp = &X[0]
etc etc

tu feras à chaque tour de boucle xp++ (si c'est bien ça), et non &X[0] + i*sizeof(type-de-X) que fait X[i]..

tu économises donc une multiplication à chaque fois, et au total pour une variable 3 multiplications et deux additions.


Exemple :

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
 
int *xp, *yp, *zp ;
 
xp = &X[0] ;
yp = &Y[0] ;
zp = &Z[0] ;
 
for(i=0; i< NbrAcc; i=i+2){	
	*xp = spi_transfer(0x00)<<8; 		//X_MSB byte
	*xp |= spi_transfer(0x00);			//X_LSB byte
	*yp = spi_transfer(0x00)<<8; 		//Y_MSB byte
	*yp |= spi_transfer(0x00);			//Y_LSB byte
	*zp = spi_transfer(0x00)<<8; 		//Z_MSB byte
	*zp |= spi_transfer(0x00);			//Z_LSB byte	
 
	buffer_writeDouble(*xp);		//Store data 1/2 to buffer
	buffer_writeDouble(*yp);
	buffer_writeDouble(*zp);
 
             xp++ ; yp++ ; zp++ ;
 
	*xp = spi_transfer(0x00)<<8; 		//X_MSB byte
	*xp |= spi_transfer(0x00);			//X_LSB byte
	*yp = spi_transfer(0x00)<<8; 		//Y_MSB byte
	*yp |= spi_transfer(0x00);			//Y_LSB byte
	*zp = spi_transfer(0x00)<<8; 		//Z_MSB byte
	*zp |= spi_transfer(0x00);			//Z_LSB byte	
 
             xp++ ; yp++ ; zp++ ;
	}	
}

là j'ai repris ton code (tout stocker), mais avec une boucle sur 2.

[pfeuh]

Moi je ferais (si j'ai bien compris qu'il te faut lire à tout coup)

Bien vu, du coup le mien devient;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
NbrAcc >>= 1; /* division pas 2 */
while(NbrAcc--)
{
        buffer_writeDouble((spi_transfer(0x00)<<8) + spi_transfer(0x00));
        buffer_writeDouble((spi_transfer(0x00)<<8) + spi_transfer(0x00));
        buffer_writeDouble((spi_transfer(0x00)<<8) + spi_transfer(0x00));
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
}

Je crois que de toute façon, le truc qui limite la vitesse, c'est plus la transmission spi que le peu de soft qu'il y a autour.

A+

Pfeuh