Bienvenue aux nouveaux arrivants sur FantasPic !

- 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 ---
Forum général sur l'Assembleur !

Modérateur : mazertoc

appel aux specialistes ASM decalage 96 bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1372
Enregistré en : juillet 2016
Localisation : Terre

#51 Message par Temps-x » dim. 10 nov. 2019 02:39

Bonjour paulfjujo, et tout le forum,


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é, :sifflotte: c'est du basic....

TOURNE.zip

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


:roll: Elle possède pas de doublon...... :roll: 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 ....... exit

==> A+
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Modifié en dernier par Temps-x le dim. 10 nov. 2019 21:33, modifié 1 fois.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

appel aux specialistes ASM decalage 96 bits
JMarc
Confirmé
Confirmé
Messages : 557
Enregistré en : août 2016
Localisation : Dans le Sud...

#52 Message par JMarc » dim. 10 nov. 2019 17:52

Temps-x a écrit :Bon, je vous est donnée la rotation à gauche, alors qui va trouver comment on fait une rotation à droite ....... exit

==> A+


Y a cas tourner le circuit imprimé. exit

appel aux specialistes ASM decalage 96 bits
Claudius
Avatar de l’utilisateur
Passioné
Passioné
Messages : 209
Âge : 64
Enregistré en : septembre 2015
Localisation : ELANCOURT (78 - YVELINES)
Contact :

#53 Message par Claudius » dim. 10 nov. 2019 20:36

Bonsoir,

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
Modifié en dernier par Claudius le lun. 11 nov. 2019 09:40, modifié 2 fois.

appel aux specialistes ASM decalage 96 bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1372
Enregistré en : juillet 2016
Localisation : Terre

#54 Message par Temps-x » dim. 10 nov. 2019 21:17

Bonjour, JMarc, Claudius, et tout le forum,

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


:eek: ..Yes,.... :bravo: ==> et Merci ! pour la correction orthographique, ainsi que l’optimisation du code... ça fait plaisir de voir des professionnelles intervenir.

Je retiens la leçon :oops:

JMarc a écrit :Source du message Y a cas tourner le circuit imprimé. exit


:lol: Tricheur.... ...:langue:

==> A+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

appel aux specialistes ASM decalage 96 bits
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1499
Âge : 69
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#55 Message par paulfjujo » lun. 11 nov. 2019 20:59

bonsoir,


oui , OK pour 1 ligne ..
mais pour les 8 autres lignes ?
Aides toi, le ciel ou Fantastpic t'aideras

appel aux specialistes ASM decalage 96 bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1372
Enregistré en : juillet 2016
Localisation : Terre

#56 Message par Temps-x » lun. 11 nov. 2019 21:50

Bonsoir, paulfjujo, et tout le forum,

:sifflotte: 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+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

appel aux specialistes ASM decalage 96 bits
satinas
Passioné
Passioné
Messages : 420
Enregistré en : novembre 2015

#57 Message par satinas » mar. 12 nov. 2019 13:56

Bonjour,

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.

appel aux specialistes ASM decalage 96 bits
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1499
Âge : 69
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#58 Message par paulfjujo » mar. 12 nov. 2019 21:07

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 entie
rs 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 ?

oops je ne pensais pas que ce puisse etre aussi CAPILOTRACTé !
Aides toi, le ciel ou Fantastpic t'aideras

appel aux specialistes ASM decalage 96 bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1372
Enregistré en : juillet 2016
Localisation : Terre

#59 Message par Temps-x » mer. 13 nov. 2019 02:20

Bonsoir paulfjujo, satinas, et tout le forum,

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.... oops

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 :sifflotte: l'outil indispensable pour rester des jours à chercher les erreurs causés par leurs créateurs. :roll:

Je sens que les adeptes de MikroC vont me tomber dessus. exit , 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 :wink:

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

Merci ! à 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

:sifflotte: Au point ou j'en suis, je me demande si je devrais pas écrire tout le programme en ASM, avec gestion SPI. :roll:

==> A+
Modifié en dernier par Temps-x le jeu. 14 nov. 2019 01:54, modifié 5 fois.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

appel aux specialistes ASM decalage 96 bits
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1499
Âge : 69
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#60 Message par paulfjujo » mer. 13 nov. 2019 10:40

Temps-x a écrit :
:sifflotte: Au point ou j'en suis, je me demande si je devrais pas écrire tout le programme en ASM, avec gestion SPI. :roll:

==> A+


:sifflotte: 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,
      bra lire     
       return


j'ai l'impression que cette fonction ne fait pas grand chose ?
un ; de trop ?
oops .. 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
,
      bra lire     
       return



je vais retester un peu tout cela
et aussi la proposition de SATINAS

Merci ! à vous tous

feuilleton à suivre ...
Aides toi, le ciel ou Fantastpic t'aideras


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 0 invité