Répondre à la discussion
Affichage des résultats 1 à 5 sur 5

programation assembleur



  1. #1
    nkoghe12001

    programation assembleur


    ------

    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.

    -----

  2. #2
    DavidDB

    Re : programation assembleur

    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.

  3. #3
    nkoghe12001

    Re : programation assembleur

    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

  4. #4
    DavidDB

    Re : programation assembleur

    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.

  5. A voir en vidéo sur Futura
  6. #5
    umfred

    Re : programation assembleur

    Voir ma réponse à ton autre post sur ce sujet

Discussions similaires

  1. programation
    Par amineln dans le forum Électronique
    Réponses: 2
    Dernier message: 10/09/2007, 20h03
  2. programation orientée
    Par c_a_r_a_83 dans le forum Logiciel - Software - Open Source
    Réponses: 2
    Dernier message: 31/08/2007, 12h59
  3. programation de microcontroleur
    Par justadream dans le forum Technologies
    Réponses: 8
    Dernier message: 12/01/2007, 22h30
  4. Programation en Fortran
    Par $ µ L v @ i N dans le forum Logiciel - Software - Open Source
    Réponses: 6
    Dernier message: 05/11/2006, 10h49
Découvrez nos comparatifs produits sur l'informatique et les technologies.