;*********************************************************************************

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