IRQ sur le 68HC11F1

[invite06909014]

bonjour,

Je n'arrive pas a faire fonctionner l'interruption IRQ sur le 68HC11F1.
Je ne sais pas comment il faut le déclarer et comment il faut l'utiliser après.

Merci d'avance pour toute réponse
-----

[invite8e6b42f1]

il te faut ou doit aller le programme lors d'une interuption ( appeler je croit vecteur d'interuption )

pour cela tu met l'origine du programme dans le vecteur

par exemple, si ton vecteur est en FFF2&FFF3 et que ton programme commence en 6000

tu met 6000 a l'adresse FFF2-FFF3

voila la doc du 68HC11F1 pour savoir ou sont les vecteur
http://www.enseirb.fr/~kadionik/68hc11/f1rgr2.pdf

[invite8e6b42f1]

bingo, va voir sur le pdf que je t'ai filer, page 7 ( en bas de la page )

IRQ/ : FFF2,FFF3
XIRQ/ : FFF4,FFF5

donc, quand ta broche IRQ/ va avoir un front descendant, le micro-controleur va aller voir ce qu'il y a au adresse FFF2,FFF3. si par exemple, tu as mis $6000, ca veux dire que ton sous programme d'interuption commence en $6000

donc, quand tu programme :
org $FFF2
fdb $6000 ; (pour fdb, j'en suis pas sur.... ou bien fcb )

______________________________ _____________________
rien a voir avec ton post, tu programme chez toi ou c'est au lycée car :
moi, c'est au lycée avec un EVM ( truc de fou )
chez moi je me suis fabriquer un kits de developppement 68FC11F1 ( electroniqe pratique 225 )
et je ne comprend pas trop comment ca fonctionne : quel soft utiliser ?
j'ai trouver ca : HC11 Asm Debugger
il a l'air tres bien comme soft, il me manque juste le fichier asm11.exe que je cherche

[invite06909014]

merci pour ta reponse, j'ai pas encore essaye mais je pense que ca marchera.
je programme chez moi et j'utilise umps. par contre tu le trouveras pas sur internet. mais il est génial. On peut programmer avec plein de langages notamment ts les hc11. Pour ton fichier asm11.exe, je ne l'ai pas, le logiciel utilise pas des .exe mais des .cpu

[A voir en vidéo sur Futura]

[invite06909014]

re

En fait j'ai voulu tester si ca marchait. Dc je l'ai declare mais je sais pas non plus comment on l'utilise. Je crois qu'il faut utiliser cli et sei ???

ca serait hyper cool si tu savais ca aussi

ci d'avance

[invite8e6b42f1]

oui, il faut initialiser quelque chose pour autoriser XIRQ

pour ma par, ce que je fait ( ca marche au lycée )

ldaa #$00
TAP : A dans le CCR

et normalement, c'est bon

*il faut que tu sache aussi que chaque sous programme d'interuption doit se terminer par l'instruction RTI ( return to interupt ) ( sauf bien sur si tu sais ce que tu fait )
*on ne peux faire une interuption si y'a a une qui est en route ( encore une fois, y'a moyen mais c'est a eviter )
*lors de l'interuption, on as un stockage dans la pile de toute les instructions de registre ( accu A & B, X, Y, )
ordre d'emplilement ( type LIFO ( Last IN, Fisrt OUT )
PCl - PCh - Yl - Yh - Xl - Xh - A - B - CCR
------------- emplilement--------------->
<-----------deempilement----------------

______________________________ _______________
pour IRQ :
Demande masquable ( par le bit I du CCR)
I=0 : autorise l'interuption ( CLI = clear I )
I=1 : ignore l'interuption ( SEI = set I)
( je croit que par defaut, I=0 )

______________________________ ________________
pour XIRQ
demande non masquable
au reset, X=1 dans le CCR : par defaut, XIRQ sera inhibé
si besoin, on valide XIRQ en placant X=0 avec l'instruction "TAP"
le bit X ne pourra plus passer a 1

[invite06909014]

oki

donc si j'ai bien compris, il faut faire:

ldaa #$00
TAP

cli
boucle tant que IRQ=0
sei

en fait j'ai vraiment du mal a comprendre comment ca marche. Je sais meme pas comment faire la boucle. Comment le programme sait quand l'interruption a eu lieu (c'est bien IRQ qui doit passer a 0).

[invite8e6b42f1]

cli et tap, tu les mets au debut du programme ,lors de l'initialiation

si je me souvient bien :
au debut du programme, I=0...les interuption sont autorisé
...... le programme se deroule.....
arrive une interuption !
alors, I passe a 1 pour interdire qu'une autre interuption ne survienne
.....
avec rti, I repasse a 0 pour pour a nouveau les autorisers

bon, j'en suis pas sur, mais ca doit etre comme ca
______________________________ ____
pour ta boucle, tu peut faire un branchement plus haut par exemple.... ca depend du programme

[invite06909014]

lut

ben la j'ai reussi a faire fonctionner l'interruption IRQ. Le probleme c'est que je n'arrive pas a decider ou aller apres cette interruption. Ca me remet directement au tout debut du programme alors que moi je voudrais aller a un endroit precis du programme.

[invite8e6b42f1]

est tu sur, d'avoir stocker en FFF2-FFF3 ( pour IRQ ) l'adresse a laquelle tu veux aller?

[invite5d44ee6f]

Salut

J'ai déjà programmé sur HC11 mais depuis je suis passé aux PICs, je vais essayé d'expliquer le mécanisme qui reste quasiment le même.

Comme Ryback08 l'a très bien expliqué les interruptions ont un vecteur : une adresse ! Prenons par exemple IRQ : Au démarrage ton programme se déroule normalement sitôt qu'un front déscendant sera détecté par la broche IRQ, le programme s'interrompt et va voir à l'adresse $FFF2 et sitôt le sous programme d'interruption terminé par l'instruction RTI, le programme reprend là ou il s'etait interrompu.

J'ai aussi une carte de développement pour 68HC11F1 ainsi qu'une carte de 68HC811E2, avec le HC811E2 on peut programmer en C, si je retrouve les schémas structurel je les posterais au fil de ce post

A très bientôt

Patrick

[invite06909014]

lut

En fait j'ai bien compris comment ca marche maintenant. Mais j'arrive pas a savoir ou est cette adresse $FFF2.

Moi j'ai mis ca en debut de programme:

IRQ equ $ee

org $FFF2
fdb IRQ
rti

En fait je voudrais juste la partie du programme qui me permet une fois que l'interruptiona eu lieu d'aller a la suite de mon programme.
Je voudrais qu'il aille a l'adresse $FFF2 et qu'il revienne tout de suite juste apres boucle qui permettait d'attendre l'interruption.

[Jack]

salut,

je crois que tu n'y es pas du tout.

Il te faut d'une part écrire ton programme d'interruption. On va dire qu'il commence par l'étiquette sp_it:

sp_it: 1ère instruction
2ème instruction
:
etc...
cli ; car il faut revalider les interrutions
rti ; retour


ensuite il faut initialiser le vecteur d'interruption. Il existe plusieurs méthodes, mais celle-ci devrait te convenir:


org $fff2
dw sp_it ; définition du vecteur

pour le dw, ça dépend de la syntaxe de ton assembleur, mais en général, c'est reconnu.

Voilà, bon courage.

A+

[invite06909014]

salut

ben ca marche toujours pas.
Le programme d'interruption, c'est ce que tu realises avt ou apres l'interruption ??????????
Et le vecteur d'interruption tu l'initialises bien au tout debut du programme avec les constantes ???????

[Jack]

qu'est-ce qui te fait dire que ça ne marche pas?

Le programme d'interruption est le programme qui est exécuté suite à une demande d'interruption, par l'entrée IRQ par exemple.

Quant à l'endroit dans ton programme source où tu procèdes à l'initialisation des vecteurs d'interruption, il n'y a pas de règle à proprement parler.
Personnellement, je le fais en fin du programme source, mais il suffit que tu aies bien fait cette définition dans ton source.

J'ajoute enfin une petite rectification à ce que j'ai écrit dans mon post précédent: il n'est pas obligatoire de revalider les interruptions avant rti, puisque le registre ccr est sauvegardé avant l'exécution du programme d'interruption.

A+

[invite4c7a167b]

Regarde ce bout de code (ce n'est pas la bonne syntaxe mais c'est pour expliquer) :

         ORG   $F800
MON_PROG_PRINCIPAL
         ...
         ...
         ...
         ...
END

MON_PROG_INTERRUPT
         ...
         ...
         ...
         ...
         RTI

         ORG   $FFF2
         JSR    MON_PROG_INTERRUPT

Nous sommes bien d'accord pour dire que ton programme démarre en $F800 !
Bon imagine que ton programme tourne et qu'il n'a pas encore atteind le END.
Soudain la broche IRQ/ passe à 0.
Le micro-contrôleur réagit et dit "Stop !!!", une interruption à eu lieu.
Celui ci vient regarder la quelle a fait stoper le micro.
Il voit que c'est l'interruption IRQ/.
Il saute au vecteur d'interruption de IRQ/, qui se trouve d'après la doc du 68HC11 à l'adresse $FFF2, pour voir ce qu'il a à faire.
Donc le micro saute à l'adresse $FFFE et il voit JSR (Jump Sub Routine) MON_PROG_INTERRUPT.
Bon comme tout sous programme, il saute à l'étiquette MON_PROG_INTERRUPT et exécute toutes les instructions jusqu'au RTI (Tu viens d'exécuter ton programme d'interruption du vecteur IRQ/).
Puis il revient dans le programme principale au moment ou il avait été interrompu (donc la ligne mise en gras).

Voilà en gros comment ça fonctionne les interruptions, c'est pas plus compliqué que ça.

[invite06909014]

J'ai tres bien compris mais ca veut decidement pas marcher.
J'ai fait ce que tu m'as di.

Mais moi quand il y a l'interruption, le programme ne va pas a l'adresse $FFF2 mais retourne tout au debut du programme.

[Jack]

Je cite l'illuminé :

Donc le micro saute à l'adresse $FFFE et il voit JSR (Jump Sub Routine)

As-tu déjà vraiment utilisé les interruptions du HC11? Le mécanisme de branchement ne fonctionne pas du tout comme ça. En cas d'interruption, le hc11 va chercher deux octets dans la table des vecteurs d'interruption qu'il va placer dans le compteur ordinal puis reprendre l'exécution du programme. A aucun moment, il ne va exécuter du code dans la table des vecteurs, donc ton jsr ... n'est pas possible.
La preuve, jsr MON_PROG_INTERRUPT va occuper 3 octets alors qu'un vecteur en prend 2 (le vecteur suivant est celui de l'interruption non masquable XIRQ et se trouve en $fff4, c'est-à-dire $fff2+2).

Pour yogui maintenant.
Comment testes-tu ton programme? avec un simulateur, avec un émulateur type kit EVM motorola?
Comment vois-tu que le programme repart au début du programme?

Si ton programme redémarre, c'est qu'un reset est généré.
Tu t'es peut-être trompé sur ta carte et la demande d'interruption est reliée à la patte reset du hc11 au lieu de la patte irq.

A+
Balise Quote ajoutée. Merci de penser à l'utiliser.
JPL modérateur

[Jack]

j'ai remis la main sur un petit programme qui génère un signal carré à l'aide d'un timer. Il va falloir que tu remettes toutes les tabulations.

La première ligne insère la définition des adresses des registres.



#include "regs.s07"

col 180
pile equ $7f
ad_reg equ $1000
om2 equ %01111111 ; mode OC2
ol2 equ %01000000 ; level OC2
oc2f equ %01000000 ; flag OC2
oc2i equ %01000000 ; masque d'interruption OC2
periode equ 80 ; 1/2 période du signal
eeprom equ $f800

org eeprom
start equ *
lds #pile
ldx #ad_reg

bclr tctl1,x,#om2
bset tctl1,x,#ol2 ; OC2 en mode bascule
bset tmsk1,x,#ol2 ; Interruption sur OC2 autorisée

ldd tcnt,x
addd #periode
std toc2,x ; activation de OC2
cli ; validation des interruptions
bra * ; attend les interruptions

sp_it equ * ; sous programme d'interruption
ldd toc2,x
addd #periode
std toc2,x
bset tflg1,x,#oc2f ; reset flag OC2
rti

org $ffe6
dc.w sp_it

org $fffe
dc.w start

end start

[invite4c7a167b]

As-tu déjà vraiment utilisé les interruptions du HC11?

Oui mais il y a bien longtemps. D'ailleurs c'est vrai que je me suis trompé et tout bien réfléchi mon explication ressemble plus à celle d'un PICmicro® dont je me sers beaucoup. Désolé !

[Jack]

pas grave,

d'ailleurs certains moniteurs implantés en mémoire morte exploitent des pseudo vecteurs qui effectuent des jmp ...

Mais pour yogui ça n'est pas le cas.

A+

[invite06909014]

salut

Merci a tous. J'ai reussi a le faire fonctionner en 68hc11 et il marche meme sur ma carte.