- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.
--- L’équipe FantasPic ---
Modérateur : mazertoc
J'ai enfin trouvé la solution, grâce au programme Led-Matrix, savait fait sous Dos un petit programme en QuickBasic pour bien comprendre le principe, je le mets à disposition avec la source pour les plus intéressé, c'est du basic....
Revenons au langage ASM, ci-dessous j'ai écrit le programme pour une rotation à gauche, dans ce code la rotation se fait sur 64 bits, si vous rajoutez des matrices en plus, il faut juste faire (8 bits x Nombre de Matrice) = sortie
Exemple pour 8 matrices, pour une rotation à gauche
Code : Tout sélectionner
;***********************************************************************************************
;************ "La rotation vers la gauche à était testé avec succès, sous MPLAB" ***************
;***********************************************************************************************
Errorlevel-302 ; Supprime le message "Ensure that bank bits are correct"
list p=18f26K22 ; processeur utilisé
#include <p18f26K22.inc> ; Définitions des constantes
;***********************************************************************************************
; CONFIG11H
CONFIG FOSC = INTIO67
CONFIG FCMEN = OFF
CONFIG IESO = OFF
; CONFIG2L
CONFIG PWRTEN = OFF
CONFIG BOREN = OFF
CONFIG BORV = 190
; CONFIG2H
CONFIG WDTEN = OFF
CONFIG WDTPS = 1
; CONFIG3H
CONFIG CCP2MX = PORTC1
CONFIG PBADEN = OFF
CONFIG CCP3MX = PORTC6
CONFIG HFOFST = OFF
CONFIG T3CMX = PORTC0
CONFIG P2BMX = PORTC0
CONFIG MCLRE = INTMCLR
; CONFIG4L
CONFIG STVREN = OFF
CONFIG LVP = OFF
CONFIG XINST = OFF
CONFIG DEBUG = OFF
; CONFIG5L
CONFIG CP0 = OFF
CONFIG CP1 = OFF
CONFIG CP2 = OFF
CONFIG CP3 = OFF
; CONFIG5H
CONFIG CPB = OFF
CONFIG CPD = OFF
; CONFIG6L
CONFIG EBTR0 = OFF
; CONFIG6H
CONFIG EBTR1 = OFF
; CONFIG7L
CONFIG EBTR2 = OFF
; CONFIG7H
CONFIG EBTR3 = OFF
;*************************************** assignations *****************************************
;
;
;
;
;
;**********************************************************************************************
;****************************** déclaration des variables *************************************
;**********************************************************************************************
CBLOCK H'0'
netoyer :1
temps :15
sortie :1
ENDC
;**************************** adresse de depart après reset **********************************
ORG H'0'
bra debut
;********************************* interruption haute priorité *********************************
ORG H'8'
retfie
;********************************* interruption basse priorité *********************************
ORG H'18'
retfie
debut
;***********************************************************************************************
;***************** "configuration de la bank sélectionné du microcontrôleur" *******************
;***********************************************************************************************
movlw B'00000000' ; même si par defaut le microcontrôleur démarre avec
movwf BSR ; BSR = 0 , je préfére en être sur.
;***********************************************************************************************
;******************** "configuration de l'oscillateur du microcontrôleur" **********************
;***********************************************************************************************
; movlw B'01110100' ; oscillateur à 16 Mhz, fréquence stable si PLL (16 * 4)= 64 Mhz
movlw B'01100100' ; oscillateur à 8 Mhz, fréquence stable si PLL (8 * 4) = 32 Mhz
; movlw B'01010010' ; oscillateur à 4 Mhz, fréquence stable
; movlw B'01000010' ; oscillateur à 2 Mhz, fréquence stable
; movlw B'00110010' ; oscillateur à 1 Mhz, fréquence stable
movwf OSCCON
;**************************** configuration du registre OSCTUNE ********************************
movlw B'00000000' ; bit 6 à 1 : PLL * 4
movwf OSCTUNE ; bit 6 à 0 : PLL désactivé
;***********************************************************************************************
;*************** "configuration du convertiseur analogique du microcontrôleur" *****************
;***********************************************************************************************
;*************************** configuration du registre ANSELA **********************************
movlw B'00000000' ; en mode numérique :
movwf ANSELA ; en mode E/S : 2(RA0), 3(RA1), 4(RA2), 5(RA3), 7(RA5)
;**************************** configuration du registre ANSELB *********************************
movlw B'00000000' ; en mode numérique :
movwf ANSELB ; en mode E/S : 21(RB0), 22(RB1) 23(RB2), 24(RB3), 25(RB4), 26(RB5)
;**************************** configuration du registre ANSELC *********************************
movlw B'00000000' ; en mode numérique :
movwf ANSELC ; en mode E/S : 13(RC2), 14(RC3), 15(RC4), 16(RC5), 17(RC6), 18(RC7)
;***********************************************************************************************
;*********************** "configuration des pattes du microcontrôleur" *************************
;***********************************************************************************************
;************ configuration des registres TRISA & TRISB & TRISC & TRISE en bank 1 **************
movlw B'00000000' ; RA0(2), RA1(3), RA2(4), RA3(5), RA4(6), RA5(7), RA6(10), RA7(9)
movwf TRISA ;
movlw B'11111111' ; RB0(21), RB1(22), RB2(23), RB3(24), RB4(25), RB5(26), RB6(27), RB7(28)
movwf TRISB ;
movlw B'00000000' ; RC0(11), RC1(12), RC2(13), RC3(14), RC4(15), RC5(16), RC6(17), RC7(18)
movwf TRISC ;
movlw B'00001000' ; RE3(1)
movwf TRISE ;
; VSS(8), VSS(19), VDD(20)
;**************************** configuration du registre INTCON2 ********************************
movlw B'00000000' ; B7 = 0 résistances en service
movwf INTCON2 ;
;**************************** configuration du registre WPUB ***********************************
movlw B'11111111' ; tirage de résistance sur : RB0(21), RB1(22), RB2(23), RB3(24), RB4(25), RB5(26), RB6(27), RB7(28)
movwf WPUB ; pas de tirage de résistance sur :
;**************************** configuration du registre INTCON *********************************
movlw B'00000000' ;
movwf INTCON ; interruption hors service
;*********************************** "départ du programme" *************************************
movlw D'15' ; nombre de variable à remettre à zéro
movwf netoyer
lfsr FSR0,temps+0 ; se placer au début de l'adresse de la variable "temps"
efface_1 ; mettre toutes les variables "temps" quand va utiliser à zéro
clrf INDF0
incf FSR0L,F
decfsz netoyer,F
bra efface_1
ini_1
movlw D'64'
movwf sortie ; 8 matrice x 8 points = 64
;***********************************************************************************************
;*************************************** "pour 8 Matrice" **************************************
;***********************************************************************************************
tourne_1
btfsc temps+7,7 ; regarder si le bits 7, de la variable "temps+7" est 1
bsf STATUS,C ; oui, en incrémennte carry à 1
btfss temps+7,7 ; regarder si le bits 7, de la variable "temps+7" est 0
bcf STATUS,C ; oui, en incrémennte carry à 0
rlcf temps+0,F ;
rlcf temps+1,F ;
rlcf temps+2,F ;
rlcf temps+3,F ;
rlcf temps+4,F ;
rlcf temps+5,F ;
rlcf temps+6,F ;
rlcf temps+7,F ;
suite_1
decfsz sortie,F
bra tourne_1
fini_1
nop
bra fini_1
End
Exemple pour 12 matrices, pour une rotation à gauche
Code : Tout sélectionner
;*********************************** "départ du programme" *************************************
movlw D'15' ; nombre de variable à remettre à zéro
movwf netoyer
lfsr FSR0,temps+0 ; se placer au début de l'adresse de la variable "temps"
efface_1 ; mettre toutes les variables "temps" quand va utiliser à zéro
clrf INDF0
incf FSR0L,F
decfsz netoyer,F
bra efface_1
ini_1
movlw D'96'
movwf sortie ; 12 matrice x 8 points = 96 (8 bits x Nombre de Matrice) = sortie
;***********************************************************************************************
tourne_1
btfsc temps+11,7 ; regarder si le bits 7, de la variable "temps+11" est 1
bsf STATUS,C ; oui, en incrémennte carry à 1
btfss temps+11,7 ; regarder si le bits 7, de la variable "temps+11" est 0
bcf STATUS,C ; oui, en incrémennte carry à 0
rlcf temps+0,F ;
rlcf temps+1,F ;
rlcf temps+2,F ;
rlcf temps+3,F ;
rlcf temps+4,F ;
rlcf temps+5,F ;
rlcf temps+6,F ;
rlcf temps+7,F ;
rlcf temps+8,F ;
rlcf temps+9,F ;
rlcf temps+10,F ;
rlcf temps+11,F ;
suite_1
decfsz sortie,F
bra tourne_1
fini_1
nop
bra fini_1
End
Elle possède pas de doublon...... Elle possède pas de doublon......
Bon, je vous est donnée la rotation à gauche, alors qui va trouver comment on fait une rotation à droite .......
A+
- Claudius
Passioné- Messages : 260
- Âge : 69
- Enregistré en : septembre 2015
- Localisation : ELANCOURT (78 - YVELINES)
- Contact :
La partie:
Code : Tout sélectionner
tourne_1
btfsc temps+11,7 ; regarder si le bits 7, de la variable "temps+11" est 1
bsf STATUS,C ; oui, en incrémennte carry à 1
btfss temps+11,7 ; regarder si le bits 7, de la variable "temps+11" est 0
bcf STATUS,C ; oui, en incrémennte carry à 0
...
Peut-être optimisée (2 cycles gagnés à chaque passage ;-) et corrigée d'un point de vue commentaire, en:
Code : Tout sélectionner
tourne_1
bcf STATUS,C ; positionnement à priori de carry à 0
btfsc temps+11,7 ; regarder si le bits 7, de la variable "temps+11" est 1
bsf STATUS,C ; si oui, positionnement de carry à 1
...
Edit: 2 cycles gagnés à chaque passage
Claudius a écrit :Source du message Peut-être optimisée (1 cycle de gagné à chaque passage ;-) et corrigée d'un point de vue commentaire, en:
Code : Tout sélectionner
tourne_1
bcf STATUS,C ; positionnement à priori de carry à 0
btfsc temps+11,7 ; regarder si le bits 7, de la variable "temps+11" est 1
bsf STATUS,C ; si oui, positionnement de carry à 1
..Yes,.... et pour la correction orthographique, ainsi que l’optimisation du code... ça fait plaisir de voir des professionnelles intervenir.
Je retiens la leçon
JMarc a écrit :Source du message Y a cas tourner le circuit imprimé.
Tricheur.... ...
A+
j'ai peut être la solution, mais il faut au moins 100 octets, (8x 12) X 8 = 768 bits /8 = 96 octets, on peu prendre la bank1 sur un Pic18F26K22
Code : Tout sélectionner
movlw D'96' ; sur une ligne pour 12 matrices
movwf sortie_1 ;
movlw D'8' ; en partant vers le bas, égal 8 points
movwf sortie_2 ; 768 bits = (8 X 12) X 8
tourne
bcf STATUS,C ; remettre carry à zéro
btfsc temps+11,7 ; regarder si le bits 7, de la variable "temps+11" est 1
bsf STATUS,C ; oui, en positionne carry à 1
rlcf temps+0,F ;
rlcf temps+1,F ;
rlcf temps+2,F ;
rlcf temps+3,F ;
rlcf temps+4,F ;
rlcf temps+5,F ;
rlcf temps+6,F ;
rlcf temps+7,F ;
rlcf temps+8,F ;
rlcf temps+9,F ;
rlcf temps+10,F ;
rlcf temps+11,F ;
; ===> Tu envoies tes données ici, si j'ai compris
suite_1
decfsz sortie_1,F
bra tourne
; ==> ici pour la ligne qui vient d'être fait
decfsz sortie_2,F
bra tourne
Je voudrais savoir si c'est bien le cas, si c'est bien à cette endroit que tu envoies tes données, j'ai la solution, mais avant je voudrais une confirmation.
A+
Dans le même esprit que Temps-x, en utilisant l'adressage indirect aussi pour les décalages :
Pour 8 matrices, stocker les pixels dans un buffer C de 64 octets, n'importe où en ram.
Pour 12 matrices, buffer de 96 octets.
Si le texte affiché est plus large que l'afficheur, buffer de (8 * largeur du texte) octets, et on affiche qu'une partie du buffer.
Pour 8 matrices (pas testé, à vérifier) :
Le buffer contient -> L1C8 L1C7 L1C6 L1C5 L1C4 L1C3 L1C2 L1C1 L2C8 L2C7 L2C6 ...
Code : Tout sélectionner
movffl FSR0H,save_fsrh // sauvegarder FSR0, il va être modifié
movffl FSR0L,save_fsrl
lfsr 0,buffer // adressage indirect FSR0 en début de buffer -> L1C8
movlw 8 // 8 lignes à décaler
movwf cnt,0 // variable compteur à déclarer en absolute < 0x60 (movwf cnt,ACCESS)
bcl movlw 7 // placer dans carry le pixel de gauche qui va entrer à droite
rlcf PLUSW0 // L1C1 <<= 1
rrncf PLUSW0 // L1C1 >>= 1
rlcf POSTINC0 // L1C8 <<= 1, décaler les 8 matrices sur une ligne
rlcf POSTINC0 // L1C7 <<= 1
rlcf POSTINC0 // L1C6 <<= 1
rlcf POSTINC0 // L1C5 <<= 1
rlcf POSTINC0 // L1C4 <<= 1
rlcf POSTINC0 // L1C3 <<= 1
rlcf POSTINC0 // L1C2 <<= 1
rlcf POSTINC0 // L1C1 <<= 1
decfsz cnt,1,0 // L2C8, boucler (decfsz cnt,F,ACCESS)
bra bcl
movffl save_fsrh,FSR0H // restituer FSR0
movffl save_fsrl,FSR0L
Pour la font 8x8 stockée en 0x005B, il n'y a pas de problème (voir cours Bigonoff 18F).
La ram du 18F27K42 va de 0 à 0x3FFF, on y accède :
- soit en adressage indirect, avec les registres FSR (14 bits)
- soit par MOVFF, on copie un octet de la ram vers la ram, en donnant 2 adresses 12 bits (donc limité aux banks 0 à 15)
- soit par MOVFFL, on copie un octet de la ram vers la ram, en donnant 2 adresses 14 bits (18F27K42 only)
- soit par le numéro de bank 0 à 63 placé dans BSR (6 bits), en donnant une adresse 8 bits
Il faut alors positionner le bit ACCESS/BANKED sur BANKED dans les ins asm MOVF, BTFSC, BCF, ...
- Si l'on positionne le bit sur ACCESS, le pic ne tiendra pas compte de BSR.
Il sélectionnera la bank 0 si l'adresse 8 bits est < 0x60, sinon la bank 0x3F (là ou il y a les registres du pic)
Ces 256 octets de mémoire access ont donc un moyen d'accès supplémentaire, en plus des méthodes précédentes.
Le compilateur et l'assembleur peuvent ajouter le bit ACCESS/BANKED car ils connaissent l'adresse complète, notamment si on accède à un registre ils sélectionnent le mode ACCESS. Ils privilégient le mode ACCESS, mais si on est pas en mémoire access, le BANKED est obligatoire. Dans mes exemples je spécifiais explicitement ce bit, car cela permet de visualiser le mécanisme.
Le compilateur va renseigner BSR lorsque c'est nécessaire, mais l'assembleur ne le fera pas, il faut le faire soi même.
Tu as déclaré des adresses "absolute" de 0x0016 à 0x005A. Le compilateur a donc utilisé la suite de la ram de 0x005B à 0x045A (1024 octets) pour stocker la font.
Le fait qu'elle empiète sur la mémoire access (0x5B à 0x5F) ne gêne pas. Il utilisera FSR, ACCESS, BANKED ou MOVFF pour accéder aux caractères de la font.
- paulfjujo
Expert- Messages : 2597
- Âge : 73
- Enregistré en : juillet 2015
- Localisation : 01800
- Contact :
Temps-x a écrit :.....
Je voudrais savoir si c'est bien le cas, si c'est bien à cette endroit que tu envoies tes données, j'ai la solution, mais avant je voudrais une confirmation.
A+
Je ne peux tester que sur 2 ensemble de matrices, car mes 2 autres, récement achetées , sont en defilement inverse !
Je pars donc sur un decalage 64 bits ( 2 entiers long)
et avec 8 lignes par matrice => table de 16 entiers longs
table initalisée au depart par l'affichage complet du texte (8 caracteres)" 01234567"
dans une boucle sans fin
j'affiche ensuite les 8 lignes decalées d'un bit à gauche sur les matrices via ce tableau de 16 entiers longs
1 decalage global à chaque boucle
pour voir mon texte se decaler !
reponse:
Donc, ce n'est pas à cet endroit
j'ai testé avec cela
Code : Tout sélectionner
void Shift_ALL_8_Long(void)
{
_asm {
// movlw 63
// movwf _sortie ; 8 matrice x 8 points = 64 (8 bits x Nombre de Matrice) = sortie
tourne:
bcf STATUS,C ; positionnement à priori de carry à 0
btfsc _temps+7,7,F ; regarder si le bits 7, de la variable "temps+11" est 1
bsf STATUS,C ; si oui, positionnement de carry à 1
rlcf _temps+0,F ;
rlcf _temps+1,F ;
rlcf _temps+2,F ;
rlcf _temps+3,F ;
rlcf _temps+4,F ;
rlcf _temps+5,F ;
rlcf _temps+6,F ;
rlcf _temps+7,F ;
//2em
bcf STATUS,C
btfsc _temps+15,7,F
bsf STATUS,C
rlcf _temps+8,F ;
rlcf _temps+9,F ;
rlcf _temps+10,F ;
rlcf _temps+11,F ;
rlcf _temps+12,F ;
rlcf _temps+13,F ;
rlcf _temps+14,F ;
rlcf _temps+15,F ;
//3em
bcf STATUS,C
btfsc _temps+23,7,F
bsf STATUS,C
rlcf _temps+16,F ;
rlcf _temps+17,F ;
rlcf _temps+18,F ;
rlcf _temps+19,F ;
rlcf _temps+20,F ;
rlcf _temps+21,F ;
rlcf _temps+22,F ;
rlcf _temps+23,F ;
//4em
bcf STATUS,C
btfsc _temps+31,7,F
bsf STATUS,C
rlcf _temps+24,F ;
rlcf _temps+25,F ;
rlcf _temps+26,F ;
rlcf _temps+27,F ;
rlcf _temps+28,F ;
rlcf _temps+29,F ;
rlcf _temps+30,F ;
rlcf _temps+31,F ;
//5em
bcf STATUS,C
btfsc _temps+39,7,F
bsf STATUS,C
rlcf _temps+32,F ;
rlcf _temps+33,F ;
rlcf _temps+34,F ;
rlcf _temps+35,F ;
rlcf _temps+36,F ;
rlcf _temps+37,F ;
rlcf _temps+38,F ;
rlcf _temps+39,F ;
//6em
bcf STATUS,C
btfsc _temps+47,7,F
bsf STATUS,C
rlcf _temps+40,F ;
rlcf _temps+41,F ;
rlcf _temps+42,F ;
rlcf _temps+43,F ;
rlcf _temps+44,F ;
rlcf _temps+45,F ;
rlcf _temps+46,F ;
rlcf _temps+47,F ;
//7em
bcf STATUS,C
btfsc _temps+55,7,F
bsf STATUS,C
rlcf _temps+48,F ;
rlcf _temps+49,F ;
rlcf _temps+50,F ;
rlcf _temps+51,F ;
rlcf _temps+52,F ;
rlcf _temps+53,F ;
rlcf _temps+54,F ;
rlcf _temps+55,F ;
//8em
bcf STATUS,C
btfsc _temps+63,7,F
bsf STATUS,C
rlcf _temps+56,F ;
rlcf _temps+57,F ;
rlcf _temps+58,F ;
rlcf _temps+59,F ;
rlcf _temps+60,F ;
rlcf _temps+61,F ;
rlcf _temps+62,F ;
rlcf _temps+63,F ;
// decfsz _sortie,F
// bra tourne
fini:
nop
}
}
nota :
si,je teste en boucle,au ieu d'un seul passage ,
individuellement, le decalage d'une ligne se passe bien , et se reboucle bien sur chaque long :
Re-testé avec le debugger mikroC en suivant les valeurs des entiers long concernés ..
je veux decaler les 8 lignes d'un seul bit à chaque passe
et j'affiche ensuite le tout
etc ..
Code : Tout sélectionner
do
{
// affichage sur matrice // pB est un char pointeur (char *pB;)
pB=0x0016; // pointe sur le debut de la table long temps[L16] absolute 0x0016 ;
// balaye les 8 lignes horizontales
for (j=0;j<8;j++)
{
// j evolue de 0 à7
// j+1 = position du digit numero de matrice
// *(pB+J); avec j=0 , pointe sur le 1er byte LSB du 1er entier long
// *(pB+J+8); avec j=0 , pointe sur le 1er byte LSB du 2em entier long
// etc
// affichage 8 matrices
SPI_Write_To_8x7219(j+1,*(pB+j),*(pB+8+j),*(pB+16+j) ,*(pB+24+j),
*(pB+32+j) ,*(pB+40+j),*(pB+48+j),*(pB+56+j));
Delay_ms(50);
}
// decale le contenu d'un bit
Shift_ALL_8_Long();
delay_ms(100); // pour bien visualiser c qui se passe
}
while (1);
au depart ça semble bien se passer , mais apres 3 ou 4 decalages , ça fait n'importe quoi
il faut peut etre etre à 100% ASM et integrer aussi l'ecriture SPI ?
je ne pensais pas que ce puisse etre aussi CAPILOTRACTé !
paulfjujo a écrit :Source du message j'ai testé avec cela
Ton code est plus simple que le mien, et je crois que c'est la meilleur méthode, mais il faudra charger tous les variables avant traitement....
Si il y a un décalage dans tes variables, c'est que la mémoire est touché à l'endroit ou son entreposé tes variables,la solution serait d'essayé un autre emplacement mémoire.... MikroC l'outil indispensable pour rester des jours à chercher les erreurs causés par leurs créateurs.
Je sens que les adeptes de MikroC vont me tomber dessus. , non je reviens.....
J'ai écrit le code pour 12 matrices, mais je peux l'adapter pour 8 matrices, comme on dit : Qui peut le plus, peut le moins
Comme je travaille, j'ai pas eu le temps de tester le code sous MPLAB, d'autre par il y a surement moyen d'optimiser le code, j'ai pas cherché à le faire vu l'heure tardive que j'ai fini, ici je développe l'idée qui devrait être fonctionnelle si j'ai pas fait d'erreur
à satinas pour son code que j'ai regardé avec un grand intérêt, l'idée est bonne, à voir par la suite.
J'ai retiré le code car il y avait des erreurs, je vous remets un code propre ce Week-end
Au point ou j'en suis, je me demande si je devrais pas écrire tout le programme en ASM, avec gestion SPI.
A+
- paulfjujo
Expert- Messages : 2597
- Âge : 73
- Enregistré en : juillet 2015
- Localisation : 01800
- Contact :
Temps-x a écrit :
Au point ou j'en suis, je me demande si je devrais pas écrire tout le programme en ASM, avec gestion SPI.
A+
j'allais justement te le proposer
pour simplifier et au moins ne pas faire d'aller-retour entre du C 100% et de l'ASM
Code : Tout sélectionner
;*************** "charger les 12 matrices dans la sdram, soit près de 96 octets" ***************
matrice_ini
lfsr FSR0,H'100' ; FSR0 pointe sur le début de la bank 1
lire
; rcall lecture
;
;
;
; movff WREG,POSTINC0
;
;
;
;
decfsz lecture,F
bra lire
return
j'ai l'impression que cette fonction ne fait pas grand chose ?
un ; de trop ?
.. j'avais pas bien lu le commentaire associé à l'appel de celle ci
je vais charger le texte à afficher dans la zone Ram , en C ...
ou faire pointer LFSR sur l'adresse de mon pointeur TEXTE à afficher ? avec ta fonction "activée".
Code : Tout sélectionner
== en C ==================
char CRam1[9];
char *Deb_CRam1 absolute 0x0800;
StrRamCopy(CRam1,"01234567");
==========================
;*************** "charger les 8 matrices dans la sdram, soit près de 64 octets" ***************
matrice_ini
lfsr FSR0,H'800' ; FSR0 pointe sur le début de la bank 8 (18F27K42)
lire
rcall lecture
movff WREG,POSTINC0
decfsz lecture,F
bra lire
return
je vais retester un peu tout cela
et aussi la proposition de SATINAS
à vous tous
feuilleton à suivre ...
Retourner vers « Langage ASM »
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 49 invités