This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 1 : * ; ============ Donner le programme qui copie : * ; *) 35 dans la position 20h * ; *) 'A' dans la position A0h * ; *) -5 dans la position 110h * ; *)35h dans la position 190h * ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' bank0 macro ; remplacer ces deux ;instructions par le mot bank0 bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm var1 EQU 0x20 var2 EQU 0x10 org 0x00 goto start start ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 35 - > [20h] ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; bank0 movlw 35 movwf var1 ;var1 = 35 = 0X23 : var1 de la bank0 ;00 0100000 = 20h
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 'A' - > [A0h] ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; bank1 movlw 'A' movwf var1 ; var1 = 'A' = 0x41 en ASCII : var1 de la bank1 ; 01 0100000 = A0h ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -5 - > [110h] ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; bank2 movlw -5 movwf var2 ;var2 = 11111011 = 0xFB : var2 de la bank2 ; 10 0010000 = 110h ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 35h - > [190h] ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; bank3 movlw 0x35 movwf var2 ; var2 = 0x35 : var2 de la bank3 ; 11 0010000 = 190h ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Loop goto Loop END ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; pour la simulaion voir la RAM ; voir le contenu des addreses : 20h , A0h , 110h et 190h ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; EXERCICE2 ; ========= ; Donner le programme qui : ; *) soustrait la constante 33 de l'accumulateur W (W-33) ; *) Soustrait la constante 40h de la case mémoire d'adresse 70h ([70h]-40h) ; *) qui soustrait le contenu de la case mémoire 70h de l'accumulateur W avec le résultat dans W ; ( W – [70h] -> W ) ; *) qui soustrait le contenu de la case mémoire 71h de l'accumulateur W avec le résultat dans la ; case mémoire ( W – [71h] -> [71h] ) ; ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39'
contenu_w EQU 0x20 case70h EQU 0x70 case71h EQU 0x71 bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm ;**********************************prototpe des fonctions utiliser dans cette programme************************** ; void_Wmoin33recoiW;() ; ; void_CON70Hmoin40HrecoiW;() ; ; void_WmoinCON70HrecoiW;() ; ; void_WmoinCON71Hrecoi71H;() ; ;******************************************************************************************************************* org 0X00 goto start start bank0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;fonction principale;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; main;() ;{ movlw 50 ; // w = 50; : on mettre une valeur initiale qq dans w pour le test call void_Wmoin33recoiW;(w) // W - 33 -> W : w = void_Wmoin33recoiW(w); movwf 0x21; // pour la simulaion : le resultat est stoquer dans l'adresse 0X21 ; // [0x21] = W - 33 ; movlw 0X50; // w = 0X50 : on mettre une valeur initiale qq dans w pour le test movwf case70h; // case70h = 0X50; call void_CON70Hmoin40HrecoiW;() // [70h]-40h -> W
movwf 0x22; // pour la simulaion : le resultat est stoquer dans l'adresse 0X22 movlw 0XD3 ; // w = 0XD3 : on mettre une valeur initiale qq dans w pour le test call void_WmoinCON70HrecoiW;() // W – [70h] -> W movwf 0x23 ; // pour la simulaion : le resultat est stoquer dans l'adresse 0X23 movlw 0X26 ; // w = 0X26 ; movwf case71h ; // case71h = 0X26 : pour le test movlw 0X55 ; // w = 0X55 : on mettre une valeur initiale qq dans w pour le test call void_WmCON71Hre71H;(w ,[71h]); // W – [71h] -> [71h] : [71h] = void_WmCON71Hre71H;(w ,[71h]); goto main ;} ; ;**************************definition des fonctions utiliser ***************************************************** ; ================================== ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; W - 33 -> W ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; void_Wmoin33recoiW ;{ movwf contenu_w ; contenu_w = w = 50 movlw 33 ; w = 33 subwf contenu_w,w ; w = contenu_w - w c-à-d w = w(initiale) - 33 return ;} ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; [70h]-40h -> W ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; void_CON70Hmoin40HrecoiW ;{ movlw 0x40 ; w = 0x40 subwf case70h,w ; w = case70h - w return ;} ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; W – [70h] -> W ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; void_WmoinCON70HrecoiW ;{ movwf contenu_w ; contenu_w = w = 0XD3 movf case70h,w ; w = case70h c-à-d w = [0x70] = 0X50 subwf contenu_w,w ; w = contenu_w - w c-à-d w = w - [0x70] return ;} ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; W – [71h] -> [71h] ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; void_WmCON71Hre71H ;{ movwf contenu_w ; contenu_w = w = 0X55 movf case71h,w ; w = case71h = 0X26
subwf contenu_w,w ; w = contenu_w - w c-à-d w = w - case71h = w - [0x71] = 0X55 - 0X26 = 0X2F = 00101111 movwf case71h ; case71h = w c-à-d case71h = w - [0x71] ou bien [71h] = W – [71h] = = 0X2F return ;} END ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; pour la simulaion voir la RAM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 3 ; ========== ; Donner le programme qui copie l'alphabet majuscule dans la RAM à partir de la position 190h ; ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' bank0 macro bcf STATUS,IRP endm bank1 macro bsf STATUS,IRP endm caractere EQU 0X1E0 org 0x00 goto start start bank1 movlw 90h movwf FSR ;// pointer sur la case d'addresse 190h : FSR = &[190h]; movlw 0X41 ;// ASCII de la caracere 'A' movwf INDF ;// mettre 'A' dans la case pointer par FSR c-à-d 190h movwf caractere ;// caractere = 'A'
Loop INCF FSR,f ; // pointer sur suivant : FSR++; INCF caractere,f ; // caractere++; movf caractere,w ; // w = caractere movwf INDF ; // *FSR = w ; movlw 0x5A ; // ASCII de la caractere 'Z'+1 subwf caractere,w ; // w = caractere - w; btfss STATUS,Z ; // si le contenu de caractere ateind 'Z'+1 finir, si no recomencer goto Loop ; // recomencer goto Rien ; // finir Rien goto Rien END ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; pour la simulaion voir la RAM ; voir le contenu des addreses : 190h , 191h , 192h........1A9h ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 4 ; ========== ; Comparer les contenus des cases mémoire 6Fh et EFh, s’il son égaux mettre à zéro tous les ; bits de la case 16Fh sinon mettre à 1 tous les bits de la case 1EFh ; ; résumer : ; ======== if([0XF6]==[0XEF]) { [0X16F] = 00000000 } ; else { [0X1EF] = 11111111 } ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' VAR EQU 0x6f bank0 macro bcf STATUS,RP0 bcf STATUS,RP1
;********************************* definition des fonction utiliser ************************************************ void_INIT;() ;{ bank0 movlw 0x52 ; valeur initiale pour le test movwf VAR bank1 movlw 0x66 ; valeur initiale pour le test movwf VAR return ;} ; void_CLEAR_16F;() ;{ bank2 clrf VAR return ;} ; void_MIZ1_1EF;() ;{ bank3 clrf VAR decf VAR,f return ;} ; void_DORMIR;() ;{ Loop goto Loop return ;} END ;*********************************************************************************************************** ; voir RAM adresses : 6F , EF , 16F et 1EF * ;*********************************************************************************************************** ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 5 ; ========== ; Comparer les contenus des cases mémoire 6Fh et EFh,
; si [6Fh] = [EFh] copier la lettre E dans la case mémoire 16Fh– ; si [6Fh] > [EFh] copier la lettre copier la lettre S dans la case mémoire 16Fh ; si [6Fh] < [EFh] I dans la case mémoire 16Fh ; ; résumer ; ======= ; if([6Fh] = [EFh]) { [16Fh] = 'E' ; } ; if([6Fh] > [EFh]) { [16Fh] = 'S' ; } ; if([6Fh] < [EFh]) { [16Fh] = 'I' ; } ; ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' VAR EQU 0X6F bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto void_main ;******************************************** fonction principale *********************************************** void_main;() ;{ call void_INIT bank1 movf VAR,w bank0 subwf VAR,w btfsc STATUS,Z
call void_EGALITE btfsc STATUS,C call void_SUPERIEUR btfss STATUS,C call void_INFIRIEUR call void_RIEN ;} ;************************************* fin fonction principale **************************************************** ;************************************ definition des fonctions utiliser dans cee programme ************************* void_INIT;() ;{ bank0 movlw 75 ; valeur qq pour le test movwf VAR bank1 movlw 80 ; valeur qq pour le test movwf VAR return ;} ; void_EGALITE;() ;{ bank2 movlw 'E' movwf VAR return ;} ; void_SUPERIEUR;() ;{ bank2 btfsc STATUS,Z return movlw 'S' movwf VAR return ;} ; void_INFIRIEUR;() ;{ bank2 btfsc STATUS,Z return movlw 'I' movwf VAR return ;} ; void_RIEN;()
;{ Loop sleep goto Loop return ;} ; END ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; pour la simulaion voir la RAM ; voir l'addresse : 16Fh ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 6 ; ========= ; Donner le programme qui fait clignoter une LED branchée sur RA0 avec une temporisation ; voisine de 0.5s. Sachant que le PIC est doté d'un quartz de 4 MHz, la temporisation sera réalisée à ; l'aide de boucles imbriquées ; ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' X1 EQU 0x20 X2 EQU 0x21 X3 EQU 0x22 bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1
call delay goto Loop ;} ; ;************************************************************************************************************* ; sous programme de la temporisation * ;************************************************************************************************************* delay ;{ movlw 151 movwf conteur test1 btfss PORTA,4 goto test1 goto test_d_arrite test0 btfsc PORTA,4 goto test0 goto test1 test_d_arrite decf conteur,f movf conteur,f btfss STATUS,Z goto test0 return ;} ;************************************************************************************************************ END ;************************************************************************************************************* ; * ;************************************************************************************************************** ;************************************************************************************************************** ; Exercice 8 * ;************************************************************************************************************** ; BCD 7 segments * ; * ; – On branche un bouton poussoir sur la broche RA4 de sorte que celle-ci passe à 0 quand on appuie * ; – On branche un afficheur 7 segments cathode commune sur le port C *
; – Chaque fois qu’on appuie sur le bouton poussoir, le contenu de l’afficheur doit s’incrémenter * ; Indication : Le décodage BCD-7 segment sera fait par le programme. On peut utiliser l’instruction * ; RETLW et goto calculé pour réaliser cette tache * ;************************************************************************************************************** ; shema à dessiner sur isis * ;************************************************************************************************************** ; * ; +5V * ; ^ ________ * ; |_ -| |- * ; 220oms|_| -| |- * ; |----|RA4 |- * ; | -| |- * ; button | -| |- _ * ; | -| RC |--------- |_| 7segment * ; | -| |- |_| * ; | -|________|- * ; | pic16f877 * ; |-|-|-| * ; GND * ; * ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' ;************************************************************************************************************* ; declaration des variables * ;************************************************************************************************************* cblock 0x20 ; zone des variable set_segment : 1 w_temp : 1
X1 : 1 X2 : 1 X3 : 1 endc bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto void_main ;*************************************************************************************************************** ; programme principale * ;*************************************************************************************************************** void_main;() ;{ call INITIALISATION bank0 debut clrf set_segment ;initialisation de la variable set_segment : [set_segment] = 0x00. movf set_segment,w ; w = [set_segment]. call décoder_cette_valeur ; apelle de la fonction décoder_cette_valeur , la valeur à décoder est envoier par le registre w. movwf PORTC ; charger la valeur emet par la fonction dans port c. call delay ; attender..... Loop btfsc PORTA,4 ; test l'etat de la button, goto Loop ;tant que j'ai pas apui sur le button , ne rien faire; si je clic sur le button incrimenter ;le contenu de la variable set_segment. incf set_segment,f movf set_segment,w call décoder_cette_valeur ; apelle de la fonction décoder_cette_valeur , la valeur à décoder est envoier par le registre w.
movwf PORTC ;charger le contenu envoier par la fonction décoder_cette_valeur. call delay ;............ movlw 0x09 ; w = 0x09 subwf set_segment,w ; btfss STATUS,Z goto Loop ;goto Loop si set_segment != 9. es btfsc PORTA,4 ; test l'etat de la button, goto es goto debut ;goto debut si set_segment = 9. ;} ;*************************************************************************************************************** ; definitions des sous programmes * ;*************************************************************************************************************** INITIALISATION;() ;{ bank1 movlw 0x06 ;charger la valeur 6 dans le registre w : w = 0x06. movwf ADCON1 ;tout les pins de la poete déclarer comme entrer numérique : ADCON1 = 0x06. clrf TRISC ;tout la port C en sortie : TRISC = 0x00. bsf TRISA,4 ;bit 4 de la port A en entrer : TRISA.b4 = 1 . return ;} ; décoder_cette_valeur;() ;{ movwf w_temp ;conserver le contenu de w dans w_temp (le contenu de w c'est la valeur à décoder). sublw 0x00 ; w = 0 - W btfsc STATUS,Z ;est ce que w = 0, si oui test reuisser , decoder la valeur et le resultat envoier dans w ;si no sauter l'instruction suivant retlw 0x3f ;return avec w = 0x3f movf w_temp,w ; recharger w par la valeur qon veut décoder, on fait cette instruction par ce que le contenut ; de w resque de modifier ; la méme chose se repete jusqu'à la fin sublw 0x01 btfsc STATUS,Z retlw 0x06 movf w_temp,w sublw 0x02 btfsc STATUS,Z retlw 0x5b
; * ;************************************************************************************************************** ;************************************************************************************************************** ; Exercice 9 ;************************************************************************************************************** * ; EXERCICE 9 ; ========== ; Programme qui écrit l alphabet majuscule dans la mémoire EEPROM de données à partir de la ; position 20h. * ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm ADRESSE EQU 0X10 ; bank2 DATAA EQU 0X11 ; bank2 ;***************************************************************************************************************** org 0x00 goto start start bank2 movlw 0X20 ; l'adresse ou on veut ecrire dans l'EEPROM movwf ADRESSE ; adresse = 0X20
movlw 0X41 ; la donnée à ecrire ASCII de la caracterre 'A' movwf DATAA ; dataa = 0X41 WHILEE;(DATAA != 'Z+1') ;{ call EEPROM_Write;(ADRESSE,DATAA) bank2 incf ADRESSE,f ; adresse++; incf DATAA,f ; dataa++; movlw 0x5B ; ASCII de la caractere 'Z'+1 subwf DATAA,w ; w = caractere - w; btfss STATUS,Z ; si le contenu de caractere ateind 'Z'+1 finir, si no recomencer goto WHILEE ; recomencer ;} ; bcf EECON1,WREN ; interdir l'écriture dans l'EEPROM goto Rien ; finir ;****************************************************************************************************************** Rien goto Rien ; rien fait : dormir ;*********************************< sous programme de la fonction EEPROM_Write >**************************************** EEPROM_Write;(ADRESSE,DATAA) ;cette fonction recoit 2 parametres : la donnes à ecrire dans la variable DATAA ;{ ;et l'emplacement décriture de la donnes sur l'EEPROM dans la variable ADRESSE bank2 ; et ne return rien movf ADRESSE,w movwf EEADR ; EEADR = ADRESSE ; movf DATAA,w movwf EEDATA ; EEDATA = DATAA ; bank3 bcf EECON1,EEPGD ; pointer sur mémoire EEPROM bsf EECON1,WREN ; autouriser l'écriture dans l'EEPROM movlw 55h ; recomendation de MICROSHIP ! movwf EECON2 ; recomendation de MICROSHIP ! movlw 0XAA ; recomendation de MICROSHIP ! movwf EECON2 ; recomendation de MICROSHIP ! bsf EECON1,WR ; démarer l'ecriture atender btfsc EECON1,WR ; atender la fin d'ecriture goto atender return ;} ;
;**********************************************Fin***************************************************************** END ;******************************************Remarque**************************************************************** ; * ;****************************************************************************************************************** ;************************************************************************************************************** ; * ;************************************************************************************************************** ; ;************************************************************************************************************** * ; EXERCICE 10 ; ========== ; Programme qui utilise la directive DE pour initialiser les premières positions de l'EEPROM de ; données avec la chaîne "BONJOUR CHER AMI". Le programme doit ensuite lire ces caractères (1 ; par 1) dans l' EEPROM et les copier dans la RAM à partir de la position 110h * ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm
bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm ADESSE EQU 0X20 ;***************************************< initialisation de EEPROM >********************************************** org 0x2100 DE "BONJOUR CHER AMI" ;***************************************************************************************************************** org 0x00 goto start start bank0 movlw 0X00 ; movwf ADESSE ; adresse dans l'EEPROM bsf STATUS,IRP ; bank 2 movlw 0X10 ; movwf FSR ; FSR = & 0X110; WHILEE;(DATAA != 0XFF) ; call EEPROM_Read;(ADESSE) ; bsf STATUS,IRP ; bank 2 movwf INDF ; *FSR = EEDATA; incf FSR,f ; FSR++; bank0 ; incf ADESSE,f ; ADESSE++; movlw 0XFF ; la valeur par defaut existe dans l'EEPROM est FF , si on lis FF c-à-d le mos lis est terminer bank2 subwf EEDATA,w btfss STATUS,Z goto WHILEE goto Rien Rien goto Rien ;********************************************** definition de la fonction EEPROM_Read **************************** EEPROM_Read;(ADESSE) ;{ bank0 ; movf ADESSE,w ; bank2 ; movwf EEADR ;
bank3 ; bcf EECON1,EEPGD ; pointer sur l'EEPROM bsf EECON1,RD ; démarer la l'écture bank2 ; 2 cycles machine pour finir la l'ecture movf EEDATA,w ; w = EEDATA; return; la resultat dans W ;} ; ;**********************************************<Fin>**************************************************************** END ;***************************************< Remarque >**************************************************************** ; =========== ; voir la RAM (adresse 110...) et EEPROM (adresse 00...) pour la simulation ;******************************************************************************************************************* ;************************************************************************************************************** ; ;************************************************************************************************************** ; Exercice 11 * ; Mem-Prog vers RAM ; Programme qui lit 20 positions de la mémoire programme débutant à la position 12FAh et les copie ; dans la RAM à partir de la position 110h. Attention : ; * Le contenu d’une position mémoire programme permet de remplir 2 positions de la RAM. ; * Le débordement de EEADR n’affecte pas EEADRH * ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm
;} ; delay500ms ;{ movlw 61 movwf conteur clrf TMR0 debut500ms1 bcf INTCON,T0IF debut500ms2 btfss INTCON,T0IF goto debut500ms2 decfsz conteur,f goto debut500ms1 return ;} ; ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 14 ; ========== ; Clignoter une LED reliée à RE0. La temporisation voisine de 0.5s sera réalisée à l'aide de TMR1 par ; scrutation du drapeau TMR1IF ;************************************************************************************************************** list p= 16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' #define LED PORTB,1 bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1
endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto start ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* start bank1 clrf TRISE ; E en sortie bank0 movlw b'00110000' ;bit 7 et 6: existe pas ;bit 5 et 4 : prescalier / 8 ;bit 3 : non utiliser ;bit 2 : chois de l'horloge interne du systeme ;bit 1 : demarage de Timer 1 : pas encors movwf T1CON Loop movlw 0xff movwf PORTE call delay clrf PORTE call delay goto Loop ;************************************************************************************************************* ; sous programme de la temporisation avec Timer 1 * ;************************************************************************************************************* delay bcf PIR1,TMR1IF ;baisser le flag de Timer 1 (pas obligatoire!) movlw 0xdc movwf TMR1L ;initialisation de Timer 1 pour obtenaire exactement 0,5 s pour les 8 bits les plus faibles movlw 0x0b movwf TMR1H ; pour les 8 bits les plus forts ; _________________________________________________ ; coment calculer 0,5 s ; le Timer 1 compte de 0 à 2^16 = 65536 ; T = 65536*10^-6 = 0,065536 s ; prescalier utiliser = 8, donc ; T = 0,065536*8 = 0,524288 s > 0,5 s , donc comment resoudre ce probleme?
; la repence à cette quetion peut etre resolu par plusieur méthode , mais la pus exact ; c est de modifier la valeur initiale de Timer 1 ; soit x la valeur initiale de Timer 1 : je veut T = 0,5 s ; donc 0,5 = 65536-x ==> x= 3036 = 0xbdc ; pour cette raison je met dans TMR1L dc et dans TMR1H 0b ;__________________________________________________ bsf T1CON,0 ; demarer le Timer 1 debut btfss PIR1,TMR1IF ;est ce que le Timer est terminer goto debut ;si no : repeter bcf PIR1,TMR1IF ;si oui: baisser le flag de Timer 1 return ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 15 ; ========== ; Clignoter une LED reliée à RD0. La temporisation voisine de 0.5s sera réalisée à l'aide de TMR1 est ; son interruption TMR1I ;************************************************************************************************************** list p= 16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' cblock 0x20 conteur : 1 w_temp : 1 status_temp : 1 endc #define LED PORTB,1 bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro
movwf tompo lala decfsz tompo,f goto lala nop return ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 20 ; ========== ; Sur un PIC doté d'un quartz de 4 MHz, Donner le programme qui fait l'acquisition de 40 ; échantillons du signal appliqué sur RA0, et recopie les résultats dans la RAM à partir de la ; position 190h. L'échantillonnage se fera à la vitesse la plus rapide possible ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' ;************************************************************************************************************** ; declaration des variable * ;************************************************************************************************************** tompo EQU 0X20 conteur EQU 0X21 adr_190 EQU 0X190 bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro
;============================================================================================================== delay movlw 4 movwf tompo lala decfsz tompo,f goto lala nop return ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 21 ; ========== ; Sur un PIC doté d'un quartz de 4 MHz, Donner le programme qui fait l'acquisition de 40 ; échantillons du signal appliqué sur RA0, et recopie les résultats dans la RAM à partir de la ; position 190h.avec une fréquence d’échantillonnage fe = 8000Hz ;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' ;************************************************************************************************************** ; declaration des variable * ;************************************************************************************************************** tompo EQU 0X20 conteur EQU 0X21 adr_190 EQU 0X190 bank0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm bank1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm bank2 macro bcf STATUS,RP0 bsf STATUS,RP1
bsf STATUS,IRP ; 1 µs movwf INDF ; 1 µs incf FSR,f ; 1 µs decfsz conteur,f ; 1 µs goto Loop ; 2 µs ;*****************************Remarque******************************************************************************* ; comment calculer fe = 8000 Hz * ; ============================= * ; ce fréquence dépent de 3 parametre fondammentals * ; *) le temps d'aquisition : c'est le temps entre le ferméture de l'interepteur et le démarage de la conversion * ; *) le temps de conversion de la données, il dépend de la fréquence de l'hourloge choisis * ; Tcon = 12*Tad ; avec Tad est le temps de conversion d'un bit * ; Tad = div* 1/Fosc * ; *) les instruction de commende , pour nous : Tu = 16 µs * ; * ; on choisis div = 8 ; donc Tad = 8*1/4 = 2 µs ;donc Tcon = 12*2 = 24 µs * ; donc le temps totale d'un cycle est T= Tcon + Tacq + Tu = 24 + Tacq + 16 = 40 + Tacq * ; on veut optenir f = 8000 Hz = 1/T ==> T = 1/8000 = 40*10^-6 + Tacq ==> Tacq = 1/8000-40*10^-6= 85 µs * ; conclusion pour avoir f = 8000 Hz il faut utiliser Tacq = 85 µs; * ; remarque : ce n'est pas la seule méthode on peut agir sur le temps Tu et div pour trouver la frequence demender * ; ======== * ;******************************************************************************************************************** Rien goto Rien ;============================================================================================================== delay ; 85 µs movlw 26 movwf tompo lala decfsz tompo,f goto lala nop nop return