;************************************************************************************************************** ; * ;************************************************************************************************************** ; 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

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 ;***************************prototype des fonctions utiliser dans cette programme ************************************ ; ==================================================== ; void_CLEAR_16F;(); ; void_MIZ1_1EF;(); ; void_INIT;(); ; void_DORMIR;(); ;******************************************************************************************************************* org 0x00 goto void_main ;**********************************programme principale ******************************************************** void_main;() ;{ call void_INIT bank0 movf VAR,w bank1 subwf VAR,w btfss STATUS,Z call void_MIZ1_1EF btfsc STATUS,Z call void_CLEAR_16F call void_DORMIR ;} ;******************************** fin programme principale ********************************************************

;********************************* 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

endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto main main;() ;{ call void_INIT bank0 loop bsf PORTA,0 call void_delay500ms bcf PORTA,0 call void_delay500ms goto loop ;} ; void_INIT;() ;{ bank1 clrf TRISA ; les pins A en sortie movlw 0x06 movwf ADCON1 ; les pins A utiliser en numérique return ;} ; void_delay500ms ;{ ;______________________________________________________________________________________________ movlw 205 ;1 cycle | movwf X1 ;1 cycle | boucle1 ; | ;____________________________________________________________________ | movlw 5 ;1 cycle | | movwf X2 ;1 cycle | | boucle2 ; | | ;______________________________________________ | |

movlw 161 ;1 cycle | | | movwf X3 ;1 cycle | | | boucle3 ; | | | ;__________________________________ | | |==> 2439*205-1+2+2+2= 500000 µs decfsz X3,f ;1 (2) cycle| | | | = 0.5 s goto boucle3 ;2 cycle|==>3 cycle |==>3*161-1+2+3 =487µs| ==>487*5-1+2+3=2439 µs | ;__________________________________| | | | decfsz X2,f ;1 (2) cycle | | | goto boucle2 ;2 cycle | | | ;______________________________________________| | | decfsz X1,f ;1 (2) cycle | | goto boucle1 ;2 cycle | | ;____________________________________________________________________| | return ;2 cycle | ;_____________________________________________________________________________________________| ;} ; END ;************************************************************************************************************* ; * ;************************************************************************************************************** ;************************************************************************************************************** ; Exercice 7 ;************************************************************************************************************** ; compteur impulsions * ; * ; Programme qui : * ; – Allume la LED branchée sur RB0 * ; – Compte 150 impulsions sur l'entrée RA4 (la case mémoire 70h servira de compteur) * ; – Eteint la LED branchée sur RB0 *

;************************************************************************************************************** list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' ;************************************************************************************************************* ; declaration des variable * ;************************************************************************************************************* conteur EQU 0x70 porta_avant EQU 0x20 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 main ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* main ;{ bank1 movlw 0x06 movwf ADCON1 bcf TRISB,0 bsf TRISA,4 bank0 clrf conteur Loop bsf PORTB,0 call delay bcf PORTB,0

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

movf w_temp,w sublw 0x03 btfsc STATUS,Z retlw 0x4f movf w_temp,w sublw 0x04 btfsc STATUS,Z retlw 0x66 movf w_temp,w sublw 0x05 btfsc STATUS,Z retlw 0x6d movf w_temp,w sublw 0x06 btfsc STATUS,Z retlw 0x7d movf w_temp,w sublw 0x07 btfsc STATUS,Z retlw 0x07 movf w_temp,w sublw 0x08 btfsc STATUS,Z retlw 0x7f movf w_temp,w sublw 0x09 btfsc STATUS,Z retlw 0x6f ;} ; delay ;{ clrf X1 boucle1 clrf X2 boucle2 nop nop decfsz X2,f goto boucle2 decfsz X1,f goto boucle1 return ;} ; ;************************************************************************************************************** END ;**************************************************************************************************************

; * ;************************************************************************************************************** ;************************************************************************************************************** ; 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

bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm ADRL EQU 0X20 ADRH EQU 0X21 conteur EQU 0X22 org 0x00 goto start start bank0 movlw 20 movwf conteur movlw 0XFA ; movwf ADRL ; adresse dans l'EEPROM 8 bits faible movlw 0X12 ; movwf ADRH ; adresse dans l'EEPROM 8 bits fort bsf STATUS,IRP ; bank 2 movlw 0X10 ; movwf FSR ; FSR = & 0X110; pointer sur l'adresse 0X110 _FOR;(conteur = 20;conteur>0;conteur--) ;{ call FLASH_Read;(ADRH,ADRL) ; bank2 movf EEDATH,w ; w = EEDATH ; bsf STATUS,IRP ; bank2 movwf INDF ; *FSR = EEDATAH ; incf FSR,f ; FSR++ ; movf EEDATA,w ; w = EEDATA ; bsf STATUS,IRP ; bank2; movwf INDF ; *FSR = EEDATA; incf FSR,f ; FSR++; bank0 ; incf ADRL,f ; ADRL++; movf ADRL,f ; ADRL = ADRL : utile pour l'instruction qui suit btfss STATUS,Z ;( ADRL = 0)? ADRH++ : ( goto suivant ) ; goto $ + 2 ; sauter 2 instrictions incf ADRH,f ; decfsz conteur,f ;premierment conteur-- apres la test suivant (conteur = 0) ? (goto Rien) : (goto Rien) goto _FOR ; ;} ; goto Rien Rien goto Rien

FLASH_Read;(ADRH,ADRL) ;{ bank0 ; movf ADRL,w ; bank2 ; movwf EEADR ; bank0 ; movf ADRH,w ; bank2 ; movwf EEADRH ; bank3 ; bsf EECON1,EEPGD ; pointer sur l'EEPROM PROGRAMME bsf EECON1,RD ; démarer la l'écture nop ; atender 2 cycle machine pour finir la l'ecture nop ; return ;} ; ;**********************************************<Fin>**************************************************************** END ;***************************************< Remarque >**************************************************************** ; =========== ; voir la RAM (adresse 110...124) et EEPROM PROGRAMME (adresse 12FA...130E) pour la simulation ;******************************************************************************************************************* ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 12 ; ========== ; Programme qui utilise l’interruption INT comme suit : ; Chaque fois que l’entrée RB0 passe de 1 à 0, la LED branchée sur RB1 clignote 4 fois au rythme de ; la ½ seconde ; ;************************************************************************************************************** list p= 16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' cblock 0x20 tompo1 : 1 tompo2 : 1 tompo3 : 1 endc cblock 0x70 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 bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm ;***************************prototype des fonctions utiliser*********************************** ; ; void LED_ONOFF;() ; ; void INITIALISATION;() ; ; void delay500ms;() ; ;********************************************************************************************** org 0X00 goto main ;**************************************programme de l'interuption RB0************************************************ org 0x04 movwf w_temp swapf STATUS,w movwf status_temp bank0 btfss INTCON,INTF goto fin_intereption call LED_ONOFF call LED_ONOFF call LED_ONOFF call LED_ONOFF bcf INTCON,INTF fin_intereption swapf status_temp,w movwf STATUS

swapf w_temp,f swapf w_temp,w retfie ;***************************************fin intereption ********************************************* ;****************************************programme principale **************************************** main;() ;{ call INITIALISATION; Loop goto Loop ;} ; ;****************************************fin programme principale **************************************** ;************************************definition des fonctions utiliser ************************************************ LED_ONOFF;() ;{ bsf LED call delay500ms bcf LED call delay500ms return ;} ; INITIALISATION;() ;{ bank1 movlw b'00000000' movwf OPTION_REG movlw b'10010000' movwf INTCON movlw b'00000001' movwf TRISB bank0 clrf PORTB

return ;} ; delay500ms;() ;{ movlw 65 movwf tompo1 boucle500ms1 movlw 50 movwf tompo2 boucle500ms2 movlw 49 movwf tompo3 boucle500ms3 decfsz tompo3,f goto boucle500ms3 decfsz tompo2,f goto boucle500ms2 decfsz tompo1,f goto boucle500ms1 return ;} ;******************************************************fin programme****************************************************** END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 13 ; ========== ; PIC doté d'un quartz de 4 MHz. Programme qui fait clignoter une LED branchée sur RB0, delay ; voisin de 0.5s à l'aide de TMR0 ; a) Par scrutation du drapeau T0IF (pas d'interruption) ; b) En utilisant l'interruption T0I ; ;************************************************************************************************************** list p= 16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' cblock 0x70 conteur : 1 w_temp : 1 status_temp : 1 endc #define LED PORTB,0 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 main ;************************************************************************************************************* ; programme de l'interuption RB0 * ;************************************************************************************************************* org 0x04 movwf w_temp swapf STATUS,w movwf status_temp decf conteur,f bcf INTCON,T0IF swapf status_temp,w movwf STATUS swapf w_temp,f swapf w_temp,w retfie ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* main;() ;{ bank1 movlw b'10000100' movwf OPTION_REG movlw b'10100000' movwf INTCON bcf TRISB,0 bank0 Loop bsf LED call delay500ms bcf LED call delay500ms goto Loop ;}

; ;************************************************************************************************************* ; sous programme de la temporisation * ;************************************************************************************************************* delay500ms ;{ movlw 61 movwf conteur clrf TMR0 debut500ms movlw 0x00 subwf conteur,w btfss STATUS,Z goto debut500ms return ;} ; ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 13 ; ========== ; PIC doté d'un quartz de 4 MHz. Programme qui fait clignoter une LED branchée sur RB0, delay ; voisin de 0.5s à l'aide de TMR0 ; a) Par scrutation du drapeau T0IF (pas d'interruption) ; b) En utilisant l'interruption T0I ; ;************************************************************************************************************** list p= 16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' #define LED PORTB,0 conteur EQU 0x20 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 main ;**************************************programme principale************************************************** main;() ;{ call INITIALISATION bank0 Loop call LED_ONOFF goto Loop ;} ; ;**********************************fin programme principale************************************************** ;******************************definition des fonctions utiliser******************************************** INITIALISATION;() ;{ bank1 movlw b'10000100' movwf OPTION_REG bcf TRISB,0 return ;} ; LED_ONOFF;() ;{ bsf LED call delay500ms bcf LED call delay500ms return

;} ; 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

bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto main ;************************************************************************************************************* ; programme de l'interuption RB0 * ;************************************************************************************************************* org 0x04 movwf w_temp swapf STATUS,w movwf status_temp bank0 decf conteur,f bcf PIR1,TMR1IF swapf status_temp,w movwf STATUS swapf w_temp,f swapf w_temp,w retfie ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* main;() ;{ bank1 movlw b'11000000' movwf INTCON bcf TRISD,0 bsf PIE1,TMR1IE bank0 Loop bsf PORTD,0 call delay bcf PORTD,0 call delay goto Loop ;} ;

;************************************************************************************************************* ; sous programme de la temporisation * ;************************************************************************************************************* delay ;{ movlw 8 movwf conteur bsf T1CON,0 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 debut movlw 0x00 subwf conteur,w btfss STATUS,Z goto debut return ;} ; ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 16 ; =========== ; Programme qui génère le signal ci-dessous sur la sortie RE0 en utilisant TMR1 associé à CCP1 ; ; __________ __________ ; | | | | ; | | | | ; __________| |__________| |__________ ; <--------> <--------> ; 500 µs 500 µs ;************************************************************************************************************** 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 ;************************************************************************************************************ org 0x00 goto main ;************************************************************************************************************* ; configuration des portes et des regestres * ;************************************************************************************************************* main bank1 movlw 0X06 movwf ADCON1 ; utiliser port E numérique (par defaut port E travait en analogique) CLRF TRISE ; port E en entrer bank0 movlw b'00001011' ; mode comparaison + TMR1 = 0 (voir le registre CCP1CON) movwf CCP1CON ; bits 7 : - ; bits 6 : - ; bits 5 : non utiliser mettre 0 ; bits 4 : non utiliser mettre 0 ; bits 3,2,1,0: Mode comparaison (drapeau CCP1IF + RAZ TMR1) clrf TMR1H ; initialiser TMR1H = 0 clrf TMR1L ; initialiser TMR1L = 0 movlw 0xF4 ; w = 0xF4 movwf CCPR1L ; CCPR1L = 0XF4 les 8 bits les plus faible (LSB) de CCPR1 movlw 0x01 ; CCPR1L = 0XF4 les 8 bits les plus faible (LSB) de CCPR1 movwf CCPR1H ; charger dans CCPR1 500 = 0X1F4 c-à-d F4 dans CCPR1L et 01 dans CCPR1H bank0 movlw b'00000000' ; configiration Timer 1 movwf T1CON ; bits 7 : -

; bits 6 : - ; bits 5 et 4 : préscalier 1:1 ; bits 3 : pas utiliser : valeur par defaut 0 ou 1 ; bits 2 : pas utiliser : valeur par defaut 0 ou 1 ; bits 1 : oscilateur interne : mettre 0 ; bits 0 : démarer le Timer 1 : pas maintenant mettre 0 bcf PIR1,CCP1IF ; baisser le flag de CCP1 (par pricotion) bsf T1CON,TMR1ON ; démarer le Timer 1 ;************************************************************************************************************** ; programme principale * ;************************************************************************************************************** Loop btfss PIR1,CCP1IF ; tester le flag de CCP1 si si ... goto Loop ; comf PORTE,f ; PORTE = ~PORTE bcf PIR1,CCP1IF ; baisser le flag de CCP1 (pour autre utilisation ) goto Loop ;*******************************************fin************************************************************** END ;************************************************************************************************************* ; * ;************************************************************************************************************* ; EXERCICE 18 ; =========== ; Programme qui génère le signal ci-dessous sur la sortie RB0 en utilisant TMR2 ; ; __________ __________ ; | | | | ; | | | | ; __________| |__________| |__________ ; <--------> <--------> ; 30 µs 30 µs ;************************************************************************************************************** list p= 16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' cblock 0x20 conteur : 1 w_temp : 1

status_temp : 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 main ;************************************************************************************************************* ; programme de l'interuption RB0 * ;************************************************************************************************************* org 0x04 movwf w_temp ; ces instrictions sont facultatifs dans ce programme swapf STATUS,w ; facultatifs movwf status_temp ; facultatifs bank0 comf PORTB,f bcf PIR1,TMR2IF swapf status_temp,w ; facultatifs movwf STATUS ; facultatifs swapf w_temp,f ; facultatifs swapf w_temp,w ; facultatifs retfie ;************************************************************************************************************* ; configuration des portes des variable *

;************************************************************************************************************* main;() ;{ bsf INTCON,GIE bsf INTCON,PEIE bank1 bcf TRISB,0 bsf PIE1,TMR2IE ;activer l'intereption de Timer 2 movlw 29 movwf PR2 bank0 movlw b'00000100' ; bits 6 à 3 : peéscalier = 1 ; bits 2 : démarer le Timer 2 ; bits 1 à 0 : peéscalier 2 = 1 movwf T2CON Loop ; atender l'intereption de Timer 2, il est géniré chaque 30µs NOP NOP goto Loop ;} ; ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 18-b ; =========== ; Clignoter une LED reliée à RE0. La temporisation voisine de 0.5s est réalisée à l'aide de TMR2 : ; 1) Par scrutation du drapeau TMR2IF ; 2) En utilisant l’interruption TMR2I ;************************************************************************************************************** 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 bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto main ;************************************************************************************************************* ; programme de l'interuption RB0 * ;************************************************************************************************************* org 0x04 movwf w_temp swapf STATUS,w movwf status_temp bank0 incf conteur,f bcf PIR1,TMR2IF swapf status_temp,w movwf STATUS swapf w_temp,f swapf w_temp,w retfie ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* main;() ;{ bank1 movlw b'11000000' movwf INTCON bcf TRISE,0 bsf PIE1,TMR2IE ;activer l'intereption de Timer 2 movlw 199 movwf PR2 bank0

movlw b'00100001' ; bits 6 à 3 : peéscalier = 5 ; bits 2 : démarer le Timer: pas maintenant ; bits 1 à 0 : peéscalier 2 = 4 movwf T2CON Loop clrf PORTE call delay comf PORTE,f call delay goto Loop ;} ; delay ;{ bsf T2CON,TMR2ON ;démarer le Timer movlw 125 non subwf conteur,w btfss STATUS,Z goto non return ;} ; ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ; EXERCICE 18 ; =========== ; Clignoter une LED reliée à RE0. La temporisation voisine de 0.5s est réalisée à l'aide de TMR2 : ; 1) Par scrutation du drapeau TMR2IF ; 2) En utilisant l’interruption TMR2I ;************************************************************************************************************** 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 bcf STATUS,RP0 bsf STATUS,RP1 endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto main ;************************************************************************************************************* ; programme de l'interuption RB0 * ;************************************************************************************************************* org 0x04 movwf w_temp swapf STATUS,w movwf status_temp bank0 incf conteur,f bcf PIR1,TMR2IF swapf status_temp,w movwf STATUS swapf w_temp,f swapf w_temp,w retfie ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* main;() ;{ bank1 movlw b'11000000' movwf INTCON bcf TRISE,0 bsf PIE1,TMR2IE ;activer l'intereption de Timer 2 movlw 199 movwf PR2 bank0

movlw b'00100001' ; bits 6 à 3 : peéscalier = 5 ; bits 2 : démarer le Timer: pas maintenant ; bits 1 à 0 : peéscalier 2 = 4 movwf T2CON Loop clrf PORTE call delay comf PORTE,f call delay goto Loop ;} ; delay ;{ bsf T2CON,TMR2ON ;démarer le Timer movlw 125 non subwf conteur,w btfss STATUS,Z goto non return ;} ; ;************************************************************************************************************ END ;************************************************************************************************************** ; * ;************************************************************************************************************** ;************************************************************************************************************** EXERCICE 19 list p=16f877 , r=dec #include p16f877.inc __CONFIG H'3F39' ;************************************************************************************************************* ; declaration des variable * ;************************************************************************************************************* tension EQU 0X20 tompo EQU 0X21 adr_70 EQU 0X70 adr_71 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 org 0x00 goto start ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* start bank1 movlw B'10001111' movwf ADCON1 bank0 movlw B'01000000' movwf ADCON0 bsf ADCON0,ADON ; fermer l'interepteur Loop call delay ; temps d'aquisition bsf ADCON0,GO_DONE ; démarer la convertion atender btfsc ADCON0,GO_DONE goto atender bank0 movf ADRESH,w ; w = ADRESH ; movwf adr_70 ; adr_70 = ADRESH ; bank1 movf ADRESL,w ; w = ADRESL ; bank0 movwf adr_71 ; adr_71 = ADRESL ; goto Loop ;============================================================================================================== delay ; T = 3*4-1+2+1+2+2 = 18 µs movlw 4

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

bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto start ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* start bank1 bsf TRISA,0 movlw B'10001111' movwf ADCON1 bank0 movlw B'01000000' movwf ADCON0 movlw 40 movwf conteur bsf ADCON0,ADON Loop bcf STATUS,IRP call delay bsf ADCON0,GO_DONE atender btfsc ADCON0,GO_DONE goto atender bsf STATUS,IRP movf adr_190,w movwf FSR bcf STATUS,IRP movf ADRESH,w bsf STATUS,IRP movwf INDF incf FSR,f bcf STATUS,IRP movf ADRESL,w bsf STATUS,IRP movwf INDF incf FSR,f decfsz conteur,f goto Loop Rien goto Rien

;============================================================================================================== 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

endm bank3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm org 0x00 goto start ;************************************************************************************************************* ; configuration des portes des variable * ;************************************************************************************************************* start bank1 bsf TRISA,0 movlw B'01001111' movwf ADCON1 bank0 movlw B'10000000' movwf ADCON0 ; bits 7 et 6 :Choix de l'horloge de conversion 00= 1:2 01= 1:8 10= 1:32 11:Oscillateur RC dédié au CAN ; bits 5,4 et 3: ; bits 2 : démarer la convertion ; bits 1 : - ; bits 0 : activer la convertion movlw 40 movwf conteur ; pour faire l'acquisition de 40 échantillons; bsf ADCON0,ADON ; fermer l'interepteur S; ;***************************************************************************************************************** ; programme principale ;***************************************************************************************************************** Loop bcf STATUS,IRP ; call delay ; Tacq = 85 µs bsf ADCON0,GO_DONE atender btfsc ADCON0,GO_DONE ; | goto atender ; | === > 24 µs bsf STATUS,IRP ; 1 µs movf adr_190,w ; 1 µs movwf FSR ; 1 µs bcf STATUS,IRP ; 1 µs movf ADRESH,w ; 1 µs bsf STATUS,IRP ; 1 µs movwf INDF ; 1 µs ====== > 16 µs incf FSR,f ; 1 µs bcf STATUS,IRP ; 1 µs movf ADRESL,w ; 1 µs

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

;************************************************************************************************************ END exercice 22 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 DATAA EQU 0X20 tompo1 EQU 0X21 tompo2 EQU 0X22 tompo3 EQU 0X23 org 0x00 goto start ;************************************************************************************************************** ; configuration des portes * ;************************************************************************************************************** start call EUSART_INIT bank0 movlw 'A' movwf DATAA Loop call void_dely500ms bank0 movf DATAA,w call EUSART_DATA_SEND bank0 incf DATAA,f

movf DATAA,w sublw 0X5B ;// 'Z+1' btfss STATUS,Z goto Loop bcf RCSTA,SPEN goto Rien Rien goto Rien EUSART_INIT ;{ bank1 movlw B'00100100' movwf TXSTA bank0 bsf RCSTA,SPEN bank1 movlw 12 movwf SPBRG return ;} EUSART_DATA_SEND ;{ bank0 NON btfss PIR1,TXIF goto NON movwf TXREG return ;} ; void_dely500ms;() ;{ movlw 205 movwf tompo1 boucle1 movlw 5 movwf tompo2 boucle2 movlw 161 movwf tompo3 boucle3 decfsz tompo3,f goto boucle3 decfsz tompo2,f goto boucle2 decfsz tompo1,f goto boucle1 return ;} ;

END ;********************************************************************************************************* ; ;********************************************************************************************************* EXERCICE 23 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 DATAA EQU 0X20 tompo1 EQU 0X21 tompo2 EQU 0X22 tompo3 EQU 0X23 ERR EQU 0X24 org 0x00 goto start ;************************************************************************************************************** ; configuration des portes * ;************************************************************************************************************** start bank1 clrf TRISB call EUSART_INIT Loop call void_TEST_ERREUR

call void_dely500ms call EUSART_DATA_RECEPT bank0 movwf DATAA movwf PORTB goto Loop goto Rien Rien goto Rien EUSART_INIT ;{ bank1 movlw B'00000100' movwf TXSTA bank0 movlw B'10010000' movwf RCSTA bank1 movlw 12 movwf SPBRG return ;} EUSART_DATA_RECEPT ;{ bank0 NON btfss PIR1,RCIF goto NON movf RCREG,w return ;} void_TEST_ERREUR ;{ bank0 clrf ERR btfsc RCSTA,FERR bsf ERR,0 movf ERR,w btfsc RCSTA,OERR iorlw 1 btfss ERR,0 return call void_RESET return ;} ; void_dely500ms;() ;{ bank0 movlw 205 movwf tompo1 boucle1

movlw 5 movwf tompo2 boucle2 movlw 161 movwf tompo3 boucle3 decfsz tompo3,f goto boucle3 decfsz tompo2,f goto boucle2 decfsz tompo1,f goto boucle1 return ;} ; void_RESET ;{ bank0 bcf RCSTA,SPEN nop bsf RCSTA,SPEN return ;} ; END