1. ;*********************************************************************************
*****************************
;
*
;*********************************************************************************
*****************************
; 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
2. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; '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'
3. 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
4. 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
5. 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'
6. 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
15. 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
*
16. ; – 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
17. 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.
18. 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
23. 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 ;
24. 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
33. ;}
;
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
34. 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?
35. ; 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
47. 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
49. ;=================================================================================
=============================
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
51. 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