je fais des acquisition de données d'un CAN vers le PIC16f84, le CAN (12 bit) envoie les données à l'envers ,c'est à dire le MSB en premier après bit10,bit9...bit2,bit1,LSB et ainsi de suite. Pour envoyer les données, le CAN (ADS7812) reçoit 12 tops d'horloge et il envoie chaque bit lorsqu'il reçoit un front montant et un front descendant
je programme en assembleur,quelqu'un peut-il me donner une routine pour les remettre dans l'ordre.
Salut,
Si tu travailles avec un 16F84, c'est très simple à réaliser, tu modifies la routines de réception/émission de l'octet :
si tu avais un RLF dans la routine tu remplaces par un RRF
si tu avais un RRF dans la routine tu remplaces par un RLF
P.S. : RRF -> rotation à droite par le bit C.
RLF -> rotation à gauche par le bit C.
David.
voici mon programme, il n'est pas fameux veuillez m'excuser pour cela.
PS: j'ai mis en gras ce dont j'ai besoin
*
;******************PROCESSEUR UTILISE*********************** *
LIST p=16f84
#include <p16f84.inc>
;******************CODES DE PROTECTION******************** ***
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC
;*****************LES ASSIGNATIONS****************** ***
OPTIONVAL EQU 0x08 ;pas de resistance de rappel, on prescaler
;****************DEFINITION DES CONSTANTES*************
#DEFINE LED PORTB,0 ; 0 en sortie
#DEFINE LCD_pin_D0 PORTB,1 ; 0 en sortie
#DEFINE LCD_pin_D1 PORTB,2 ; 0 en sortie
#DEFINE LCD_pin_D2 PORTB,3 ; 0 en sortie
#DEFINE LCD_pin_D3 PORTB,4 ; 0 en sortie
#DEFINE B5 PORTB,5 ; 0 en sorite
#DEFINE B6 PORTB,6 ; 0 en sorite
#DEFINE BUSY PORTB,7 ; 1 en entrée
#DEFINE DATA1 PORTA,0 ; 1 en entrée
#DEFINE CONV PORTA,1 ; 0 en sortie
#DEFINE A2 PORTA,2 ; 0 en sortie
#DEFINE DATACLOCK PORTA,3 ; 0 en sortie
#DEFINE A4 PORTA,4 ; 0 en sortie
;*****************DECLARATION DES VARIABLES*********
CBLOCK 0x0C
new:2 ;nouvelle acquisition CAN
prev:2 ;ancienne acquiqition CAN
cmpt1:1 ;compteur1
cmpt2:1 ;compteur2
cmpt3:1 ;compteur3
cmpt4:1 ;compteur4
cmpt5:1 ;compteur5
cmpt6:1 ;compteur6
tampon:2 ;variable qui prend la valeur du CAN avant traitement
zero:1 ; zero=0
Acc_A_Lo:1 ;Acc_A_Lo=2*acquisition_CAN
Acc_B_Hi:1 ;poids fort du résultat de l'opération:Acc_A_Lo*Acc_B_Lo
Acc_B_Lo:1 ;poids faible du résultat de l'opération:Acc_A_Lo*Acc_B_Lo
Acc_Cmpt:1 ;compteur de boucle
Acc_Temp:1 ;variable tampon
LCDtmp1:1 ;variable contenant les bites de poids faible de la valeur à afficher
LCDtmp2:1 ;variable contenant les bites de poids fort de la valeur à afficher
ENDC
;****************DEMARRAGE AU RESET**********************
ORG 0x00 ;adresse de demarrage
goto init
;*******************initialisa tion des ports A et B*******************
init
bsf STATUS,5 ;on passe en BANQUE 1
movlw 0x80 ;on met '1000 0000' dans le reg W
movwf TRISB
movlw 0x01 ;on met '0000 0001' dans le reg W
movwf TRISA
;*******************configurat ion du registre options***************
movlw OPTIONVAL ;on met 0x97 dans le reg w
movwf OPTION_REG ;on charge le registre option
bcf STATUS,5 ;on repasse en BANQUE 0
;*******************mise a zero des ports*************************
init1
clrf PORTA
clrf PORTB
;*******************initialisa tion du CAN************************
bsf BUSY
bsf CONV
;*******************effacer la ram*************************** ***
bsf STATUS,5 ;on passe en banque 1
movlw 0x0C ;on met l'adresse haute de la ram dans w
movwf FSR ;on pointe sur l'adresse haute de la ram
init2
clrf INDF ;on met 0 a l'adresse 0x0C
comf INDF,f
incf FSR,f ;on pointe vers l'adresse suivante
btfss FSR,6 ;on teste si la zone 0x40 est atteinte
goto init2 ;si non,on boucle
btfss FSR,4 ;si oui,teste si 0x50 est atteinte
goto init2 ;si 0x50 non atteint on boucle encore
;sinon on continue dans le programme
;*******************initialisa iotn spécifique*************
bcf LED ;LED en sortie
bcf STATUS,5 ;on repasse en BANQUE 0
;***************************** ******************************
; SOUS ROUTINES
;***************************** ******************************
test_W_S
bcf B5 ; écriture dans verrou de l'afficheur
bcf B6 ; écriture dans verrou de l'afficheur
call tempo2 ;laisser le temps d'écrire
call tempo2
bsf B5 ;envoi de caratère
bsf B6 ;envoi de caractere
call tempo2 ;laisser temps envoi
call tempo2
return
tempo
movwf cmpt3 ; initialiser compteur3
boucle
clrf cmpt2 ; effacer compteur2
boucle2
clrf cmpt1 ; effacer compteur1
boucle1
nop ; perdre 1 cycle
decfsz cmpt1,f ; décrémenter compteur1
goto boucle1 ; si pas 0, boucler
decfsz cmpt2,f ; si 0, décrémenter compteur 2
goto boucle2 ; si cmpt2 pas 0, recommencer boucle1
decfsz cmpt3,f ; si 0, décrémenter compteur 3
goto boucle3 ; si cmpt3 pas 0, recommencer boucle2
return ; retour de la sous-routine
tempo1 ;temporisation de 20ms
movlw 0x1A ;charger 26
movwf cmpt4 ; initialiser compteur4
boucle4
clrf cmpt5 ; effacer compteur5
boucle5
nop ; perdre 1 cycle
decfsz cmpt5,f ; décrémenter compteur1
goto boucle5 ; si pas 0, boucler
decfsz cmpt4,f ; si 0, décrémenter compteur 2
goto boucle4 ; si cmpt2 pas 0, recommencer boucle1
return ; retour de la sous-routine
tempo2
movlw 0x3C ; on met 60 temporisation 60 microS
movwf cmpt6 ;temps nécéssaire au CAN
boucle6
decfsz cmpt6,f
goto boucle6
return
horloge
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
call tempo2
bcf DATACLOCK
call tempo2
bsf DATACLOCK
return
acquisition
bsf CONV ;permet de démarrer la conversion
nop
nop
btfsc BUSY ;vérifier si la conversion à débuter
goto acquisition ;pas terrible à revoir
call horloge ;horloge qui fournit 14 flip-flop
btfss BUSY ;voir si la conversion est fini
call tempo1
;acquisition du CAN et mise a jour de new
movf PORTA,w ;le port A0 est envoye sur le reg w
movwf new ;port A0 est transmis a new
;mise a jour de la valeur precedente
movf new,w ;transfert de new dans le reg w
movwf prev ;on copie la valeur de new dans prev
;test si precedent est nul
movf prev,w ;on met prev dans w
btfsc STATUS,2 ;si la valeur dans prev est differente
goto acquisition ;sinon on boucle
;soustraction entre new et precedent
clrf zero ;on met 0 dans la variable
movf zero,w ;on met zero=0 dans w
subwf prev,w ;on fait la difference "prev-zero",le
;test si le resultat est negatif ( carry=0 et z=0)
btfsc STATUS,2 ;si le bit Z=0 on saute le "goto" suivant
goto acquisition
btfss STATUS,0 ;si le bit "carry" = 0 on saute le "goto"
goto acquisition
return
traitement
;***** format des données transmis part le CAN*******************
;**** MSB ,bit10,bit9...,bit2,bit1,LSB** ****************************
;CHERCHER UNE ROUTINE POUR INVERSER LES BITS
movwf tampon ;on met la valeur du CAN dans une variabl
addwf tampon,w ; multiplication par deux : w= tampon + tampon
movwf Acc_A_Lo ; Acc_A_Lo= 2*tampon
movlw 0xCA ;on met 202 dans Acc_B_Lo
movwf Acc_B_Lo
(--------,Acc_B_Lo) * (--------,Acc_A_Lo) -> (Acc_B_Hi,Acc_B_Lo)
movlw 8 ; pour 8 bits
movwf Acc_Cmpt ; initialiser compteur de boucles
movf Acc_B_Lo,W ; charger multiplicateur
movwf Acc_Temp ; sauver dans multemp
movf Acc_A_Lo,W ; multiplicande dans w
clrf Acc_B_Hi
clrf Acc_B_Lo
M_MULTI_LOOP
rrf Acc_Temp,f ; décaler multiplicateur vers la droite
btfsc STATUS,C ; tester si bit sorti = 1
addwf Acc_B_Hi,f ; oui, ajouter au résultat poids fort
rrf Acc_B_Hi,f ; décaler résultat poids fort
rrf Acc_B_Lo,f ; décaler résultat poids faible
decfsz Acc_Cmpt,f ; décrémenter compteur de boucles
goto M_MULTI_LOOP ; pas fini, bit suivant
return
affichage
movf Acc_B_Lo,w ;on copie Acc_B_Lo dans w
movwf LCDtmp1 ;on met Acc_B_Lo dans LCDtmp1
movf Acc_B_Hi,w ;on copie Acc_B_Hi dans w
movwf LCDtmp2 ; on met Acc_B_Hi dans LCDtmp2
bcf LCD_pin_D0 ; on met à 0 les sorties
bcf LCD_pin_D1 ; on met à 0 les sorties
bcf LCD_pin_D2 ; on met à 0 les sorties
bcf LCD_pin_D3 ; on met à 0 les sorties
btfsc LCDtmp1,0 ; on teste le bit 0 du caractere
bsf LCD_pin_D0 ; il est à 1 donc sortie correspondante à 1
btfsc LCDtmp1,1
bsf LCD_pin_D1
btfsc LCDtmp1,2
bsf LCD_pin_D2
btfsc LCDtmp1,3
bsf LCD_pin_D3
bcf A2 ;on met DA1=0 ,permet de choisir le digit à allumer
bcf A4 ;on met DA2=0 ,si DA1=0 et DA2=0 alors digit 4
call test_W_S ;validation d'envoi et d'écriture
;*********envoi du 2 eme quartet*********************** **********
bcf LCD_pin_D0 ; on met à 0 les sorties )
bcf LCD_pin_D1 ; on met à 0 les sorties
bcf LCD_pin_D2 ; on met à 0 les sorties
bcf LCD_pin_D3 ; on met à 0 les sorties
btfsc LCDtmp1,4 ; on teste le bit 3 du caractere
bsf LCD_pin_D0 ; il est à 1 donc sortie correspondante à 1
btfsc LCDtmp1,5
bsf LCD_pin_D1
btfsc LCDtmp1,6
bsf LCD_pin_D2
btfsc LCDtmp1,7
bsf LCD_pin_D3
bsf A2 ;on met DA1=1 ,permet de choisir le digit à allumer
bcf A4 ;on met DA2=0 ,
;si DA1(poids faible)=1 et DA2=0 alors digit3
call test_W_S ;validation d'envoi et d'écriture
;*********envoi du 3 eme quartet*********************** **
bcf LCD_pin_D0 ; on met à 0 les sorties (du poids
bcf LCD_pin_D1 ; on met à 0 les sorties
bcf LCD_pin_D2 ; on met à 0 les sorties
bcf LCD_pin_D3 ; on met à 0 les sorties
btfsc LCDtmp2,0 ; on teste le bit 7 du caractere
bsf LCD_pin_D0 ; il est à 1 donc sortie correspondante à 1
btfsc LCDtmp2,1
bsf LCD_pin_D1
btfsc LCDtmp2,2
bsf LCD_pin_D2
btfsc LCDtmp2,3
bsf LCD_pin_D3
bcf A2 ;on met DA1=0 ,permet de choisir le digit à allumer
bsf A4 ;on met DA2=1
;,si DA1=0 et DA2(poids fort)=1 alors digit2
call test_W_S ;validation d'envoi et d'écriture
;*********envoi du 4 eme quartet*********************** *
bcf LCD_pin_D0 ; on met à 0 les sorties
bcf LCD_pin_D1 ; on met à 0 les sorties
bcf LCD_pin_D2 ; on met à 0 les sorties
bcf LCD_pin_D3 ; on met à 0 les sorties
btfsc LCDtmp2,4 ; on teste le bit 11 du caractere
bsf LCD_pin_D0 ; il est à 1 donc sortie correspondante à 1
btfsc LCDtmp2,5
bsf LCD_pin_D1
btfsc LCDtmp2,6
bsf LCD_pin_D2
btfsc LCDtmp2,7
bsf LCD_pin_D3
bsf A2 ;on met DA1=1 ,permet de choisir le digit à allumer
bsf A4 ;on met DA2=1
;,si DA1(poids faible)=1 et DA2=1 alors digit1
call test_W_S ;validation d'envoi et d'écriture
return
return
;***************************** ****************************
; PROGRAMME PRINCIPAL *
;***************************** ****************************
start
movlw 2 ;temporisation de 0.5s
call tempo
bsf LED
movlw 2 ;temporisation de 0.5s
call tempo
bcf LED
movlw 2 ;temporisation de 0.5s
call tempo
bsf LED
movlw 2 ;temporisation de 0.5s
call tempo
bcf LED
movlw 2 ;temporisation de 0.5s
call tempo
bsf LED
movlw 2 ;temporisation de 0.5s
call tempo
bcf LED
movlw 2 ;temporisation de 0.5s
call tempo
bsf LED
movlw 2 ;temporisation de 0.5s
call tempo
bcf LED
movlw 2 ;temporisation de 0.5s
call tempo
bsf LED
movlw 2 ;temporisation de 0.5s
call tempo
bcf LED
movlw 0x33 ;temporisation de 10s on met
; D'51'=0x33 dans la tempo
call tempo
call acquisition ;sous routines d'acquisition
call traitement
call affichage
goto start ; boucler
END ; directive fin de programme
Bon, il y a du travail...
Il faut déjà commencer par lire et relire attentivement le datasheet du ADS7812...
Ensuite, les figures 5 à 8 vont te servir pour faire le pesudo-code d’aide à la programmation des routines de conversions.
Sans vouloir être méchant, je pense que tu peux purement et simplement envoyer dans la corbeille le programme du post# 3 tant il contient des erreurs.
Dans ton cas, vu que les données arrivent par la liaison série, il n’y a pas besoin de routines « d’inversion des bits » il te suffit simplement au moment de la lecture du bit de faire une double rotation (vu que tu travailles sur une variable de 16bits) sur les deux octets de réception avec l’instruction RLF, et la donnée aura bien le format MSB->LSB à la fin de la réception.
David.
Voir ma réponse à ton autre post sur ce sujet
