[ASM/PIC] - Division par 10

[jorg1n]

Bonjour,

j'ai un petit soucis, je travaille régulièrement avec des PICs, mais en language C, et je dois modifier un programme en assembleur.

Le principe, faire la somme de 10 résultats de mesures analogiques, et ensuite diviser le résultat par 10...

Et le soucis se trouve là, je ne vois pas du tout comment faire, je suis un novice voir pire en assembleur!!

J'ai donc mon résultat de la somme "SomMesureU" qui est sur 16 bits, et je souhaiterai le diviser par 10 et le stocké dans Ubat (16bits)...

Pourriez vous m'aider un peu?

Merci d'avance,

Bonne journée à tous!!
-----

[pichnochio]

Salut,

Je me suis penché sur le sujet, et j'ai beau essayé d'associer les décalages à gauche et ceux à droite, je n'arrive pas à en tirer une régle générale.

Du coup si quelqu'un à la réponse je suis aussi interessé

[Jack]

Il n'y a pas d'instruction de division? Ce serait sympa d'indiquer de quel µC il s'agit.

A+

[Laboum]

Bonsoir à tous,
Il y a eût une discussion intéressante sur ce sujet http://forums.futura-sciences.com/el...laide-pic.html
Bon courage

[A voir en vidéo sur Futura]

[Jack]

Il y en d'autres. Je me rappelle avoir participé à une d'entre-elle dans laquelle je donnais un algorithme qui consistait à compter le nombre de fois où l'on pouvait soustraire 10.

A+

[pazcal]

Beaucoup de gens s'obstinent à faire des moyennes sur 10 points alors qu'il est plus simple de les faire sur 8 ou 16, ce qui élimine le problème de la division par 10. Ensuite, il faudrait définir la précision souhaitée pour ta division.
La méthode de soustraction successives n'est pas idéale car elle nécessite beaucoup d'itérations pour des nombres codés sur 16 bits.
Si tu disposes de suffisamment de ressources mémoire/vitesse, tu peux faire confiance au compilateur C.
Sinon, si les échantillons que tu moyennes sont stockés sur 8 bits, il suffit de les diviser avant de les additionner. Et la une LUT est idéale car elle offre un résultat immédiat pour une taille de 256 octets :
(a + b + c + ... + j)/10 = a/10 + b/10 + c/10 + ... +j/10
A plus

[Jack]

La méthode de soustraction successives n'est pas idéale car elle nécessite beaucoup d'itérations pour des nombres codés sur 16 bits.
Si tu disposes de suffisamment de ressources mémoire/vitesse, tu peux faire confiance au compilateur C.

oui, mais là c'est de l'asm.

Sinon, si les échantillons que tu moyennes sont stockés sur 8 bits, il suffit de les diviser avant de les additionner. Et la une LUT est idéale car elle offre un résultat immédiat pour une taille de 256 octets :

Bonne idée, mais on perd de la précision en commençant par les diviser avant de les additionner. On peut aussi faire une lookup table sur 16 bits s'il y a assez de mémoire.

A+

[jorg1n]

Bonjour à tous,

Ce serait sympa d'indiquer de quel µC il s'agit.

Il s'agit d'un PIC16F874.

Beaucoup de gens s'obstinent à faire des moyennes sur 10 points alors qu'il est plus simple de les faire sur 8 ou 16, ce qui élimine le problème de la division par 10.

En ce qui me concerne, je peux m'adapter, en fait, je souhaite faire une moyenne sur plusieurs échantillons de mesures de tension. Je peux faire une division sur 16...

Ce serait plus simple ?

Pour informations, le mot binaire que je souhaite diviser est codé sur 16 bits...

Je vais regarder ton lien Laboum..

Merci d'avance,

Bonne journée à tous

[Jack]

l'idée de pazcal est bonne. Il te suffit d'additionner les 16 mesures, le tout sur 16 bits et d'effectuer 4 décalages à droite de la somme pour obtenir la moyenne.
Plus besoin d'instruction spécifique de division donc.

A+

[jorg1n]

Bonjour Jack,

bon, cette proposition me convient parfaitement...Merci bien !!

Donc, j'ai un registre de 16 bits "SomUBat" que je souhaite diviser par 16, je fais donc cela :

rrf    SomUBat,1
rrf    SomUBat,1
rrf    SomUBat,1
rrf    SomUBat,1

Par contre, ça c'est sur papier, si car dans le microcontrolleur, il s'agit de registre de travail de 8 bits.
Je vois pas trop comment faire...
Il est préférable aussi de faire un masque pour supprimer les 4 bits de poids fort, non?

Merci d'avance

[Jack]

Bonjour Jack,

bon, cette proposition me convient parfaitement...Merci bien !!

Donc, j'ai un registre de 16 bits "SomUBat" que je souhaite diviser par 16, je fais donc cela :

rrf    SomUBat,1
rrf    SomUBat,1
rrf    SomUBat,1
rrf    SomUBat,1

Par contre, ça c'est sur papier, si car dans le microcontrolleur, il s'agit de registre de travail de 8 bits.
Je vois pas trop comment faire...
Il est préférable aussi de faire un masque pour supprimer les 4 bits de poids fort, non?

Merci d'avance

si les instructions de décalage ne fonctionnenet que sur des registres de 8 bits, il faut décaler d'un bit l'octet de poids fort, puis l'octe de poids faible en réinjectant la carry, et ceci 4 fois soit en répètant les mêmes instructions, soit dans une boucle.

A+

[jorg1n]

Merci Jack,

je pensai faire comme cela:
SomUBatHI , SomUBatLO -> 2 x 8 bits (Nombre à diviser par 16)
ResultTemp -> Récupération des 4 bits de poids faible de SomUBatHI à transmettre à SomUBatLO en tant que poids fort après décalage de SomUBatLO.

Voila ce que ça donne :

	;Récupération des 4 bits de poids faible pour transfert vers SomUBatLO
	movf	SomUBatHI,0		;Stocke SomUBatHI dans W
	andlw 	b'00001111'		;ET Logique entre le registe W et b'..'
	movwf	ResultTemp		;Stocke W dans ResultTemp

	;Décalage de 4 bits vers la droite pour division par 16
	rrf    	SomUBatHI,1		;décalage à droite
	rrf    	SomUBatHI,1		;décalage à droite
	rrf    	SomUBatHI,1		;décalage à droite
	rrf    	SomUBatHI,1		;décalage à droite
	movf	SomUBatHI,0		;Stocke SomUBatHI dans W
	andlw 	b'00001111'		;ET Logique entre le registe W et b'..'
	movwf	SomUBatHI		;Stocke W dans SomUBatHI

	;Mise en forme des 4 bits pour transfert vers SomUBatLO en poids fort
	rlf		ResultTemp		;décalage à gauche
	rlf		ResultTemp		;décalage à gauche
	rlf		ResultTemp		;décalage à gauche
	rlf		ResultTemp		;décalage à gauche
	movf	ResultTemp,0	;Stocke ResultTemp dans W
	andlw 	b'11110000'		;ET Logique entre le registe W et b'..'
	movwf	ResultTemp		;Stocke W dans ResultTemp

	;Décalage de 4 bits vers la droite pour division par 16	
	rrf    	SomUBatLO,1		;décalage à droite
	rrf    	SomUBatLO,1		;décalage à droite
	rrf    	SomUBatLO,1		;décalage à droite
	rrf    	SomUBatLO,1		;décalage à droite

	;Mise en forme pour ajout 4 bits de poids fort
	movf	SomUBatLO,0		;Stocke SomUBatLO dans W
	andlw 	b'00001111'		;ET Logique entre le registe W et b'..'
	iorwf	ResultTemp,0	;OU Logique entre le registre W et ResultTemp
	movwf	SomUBatLO		;Stocke W dans SomUBatLO

Qu'en pensez vous?

[Dormeur74]

L'assembleur serait-il en régression ?

En 1992, on avait 2 instructions pour la division, à savoir DIV Source pour une division non signée et IDIV Source pour les divisions signées. Mais c'était pour les proc 8088 à 80486.

J'ai conservé toute la doc sur le sujet (16 et 32 bits), mais ignore si cela pourrait t'être utile. Pour moi, c'est beaucoup trop trop loin.

[Jack]

Qu'en pensez vous?

je ne connais pas suffisamment l'asm des pics pour commenter ton code.

L'assembleur serait-il en régression ?

En 1992, on avait 2 instructions pour la division, à savoir DIV Source pour une division non signée et IDIV Source pour les divisions signées. Mais c'était pour les proc 8088 à 80486.

les pic midrange sont des petits microcontrôleurs qu'on ne peut comparer aux microprocesseurs tels que les 8086 et successeurs.
Le pic dont il est question ne possède malheureusement ni multiplication, ni division.

A+

[Xoxopixo]

Bonjour,

je me demandais s'il ne serait pas interressant de convertir le nombre 16 bits en BDC ou peut-être mieux, en ASCII.

dans le genre
(A) 01110101 01110001
qui donne 30065 (il faut voir si on veut signé ou non signé)
Ce qui nous donne de l'ASCII
"3" 0011
"0" 0000
"0" 0000
"6" 0110
"5" xxxx

Ne pas prendre le dernier chiffre. (un division par dix donc)
On ne traite pas le "5"
Puis reconvertir de l'ASCII vers le binaire.
Il faudrais voir le set d'instruction et les registres autorisés pour y parvenir.

Si j'essai de comprendre le probleme, il s'agit de trouver une correspondance entre cet infame binaire en haut et ce merveilleux ascii plus bas.
Et vice versa.

J'ai trouvé quelques pistes ici :
http://www.piclist.com/techref/micro...adix/index.htm

Mais sinon, c'est vrai que comme dit

Bonne idée, mais on perd de la précision en commençant par les diviser avant de les additionner. On peut aussi faire une lookup table sur 16 bits s'il y a assez de mémoire.

C'est peut-être le plus direct ?

[paulfjujo]

bonsoir,

si les valeurs sont sur 16 bits, ne pas oublier de travailler avec un entier long si la somme des 16 valeurs peut deborder le format 16 bits
et
Traiter aussi le cas de la signature , si les valeurs sont signées
sur +-15bits.
Pour moyenner 10 valeurs , on peut aussi simplement accumuler la somme des valeurs , et via l'affichage , recadrer le resultat
pour afficher un simili flottant au 1/10e pres.
l'exemple ci dessous est tiré de mon appli
regulation de chauffage avec Pic16F88 , traitement d'une mesure de temperature
avec affichage au 1/10 de la valeur en cours et au
1/100em de la valeur moyenne de 10 mesures.

;***************************************
;     VARIABLES BANQUE 1               *
;***************************************
	SommeTAM
;---  variables 16 bits -----
	ConsTamb	:2	; consigne Tamb
	valx		:2
	val1		:2
	val2		:2
	val3		:2
	reste		:2
	result	:2
	TN_Amb	:2
	STF_Amb	:2


MesAmb	bank0
		movlw 0x01
		movwf Special_MAE
		bsf PORTB,4
		nop
		bcf PORTB,5
		nop
		call MemoMesure ;    acquisition mesure 16 bits
		bank1
		movf val1,W
		movwf	TN_Amb
		movf val1+1,W
		movwf	TN_Amb+1
	;Filtrage Arithmetique : accumulation des mesures 16 bits		
		movf STF_Amb,W
		movwf val2
		movf STF_Amb+1,W
		movwf val2+1
		call add16
		movf val1,W
		movwf STF_Amb
		movf val1+1,W
		movwf STF_Amb+1
		incf SommeTAM,f
		movlw 10		; on a alors 10 fois mla mesure de base ,pour affichage au 1/100 !
		subwf SommeTAM,w
		btfss STATUS,Z
		goto MesExter	; filtrage non ateint,on passe à lamesure suivante

		.... etc ..



aff_TA	call	LCD_Clear2
		movlw 1
		movwf Pointer_Msg
		Call AffNumMsgEeprom
		movlw 0x01
		movwf Special_MAE       ; pour affichage avec xxx.x au 1/10em
		MOVLW   LINE2 + 8  	; Position 8
		CALL    LCD_Cde         ; Set cursor

		bank1
		movf TN_Amb,W	  	;Temp Ambiante Now
		movwf	val1
		movf TN_Amb+1,W
		movwf	val1+1
		call bcd_temp
		bank0
		btfss Drapeaux,1
		goto aff_fin

;----------------------------------------
		;filtrage arithmetique termine ?
aff_TAF   	call delay_1s
		MOVLW LINE2 + 6  		; Position
		CALL    LCD_Cde         ; Set cursor
		movlw	 'F'
		call LCD_Putchar
		MOVLW   LINE2 + 8  	; Position
		CALL    LCD_Cde
		bsf Drapeaux,3		; pour affichage xxx.xx au 1/100e
		bank1
		movf TF_Amb,W	  	;Temp Ambiante Filtree
		movwf	val1
		movf TF_Amb+1,W
		movwf	val1+1
		call bcd_temp
		bank0
		call delay_1s
		bcf Drapeaux,1
		bcf Drapeaux,3
		goto aff_fin



;- sub routine ---------
add16	bank1
	movf   val2,w		; addition 16 bits
	addwf  val1,f		; val1 = val1 + val2
	movf   val2+1,w
	addwf  val1+1,f
	btfsc  STATUS, C
	incf   val1,f
	return

sinon, la soluce de travailler avec une moyenne sur 16 valeurs
est aussi simple
puisqu'il faudra 4 decalages à droite pour recuperer la moyenne
mais on pert les 4 bits sortants! à moins de les traiter
avec un poids de 1/16 d'unité.
ATTENTION au debordement possible de l'accumulateur ,
si celui ci est sur 16 bits seulement!