Afficher caractère Afficheur ST7920 par liason série

[damien8024]

Bonjour,

Actuellement en train de développer un projet à l'aide d'un PIC16F877, j'ai besoin de piloter un afficheur LCD 128X64, ce que je n'ai jamais fait auparavant !
Il embarque un contrôleur ST7920 et je le commande par liaison série SPI.

Cette dernière fonctionne car je peux envoyer mes instructions d'initialisation ou de placement de mon curseur.

Dans un premier temps, j'essaie d'apprendre à utiliser les caractères présents dans la GROOM avant de passer à l'affichage graphique mais même ça je n'y arrive pas !

Je suppose que je m'y prends mal et c'est pourquoi je joint un extrait de mon programme en assembleur (dsl j'ai appris comme ça et je connais pas le C) qui comporte notamment l'initialisation de l'afficheur et la sous-routine d'envoie de l'octet à l'afficheur en liaison SPI.

Je ne dois pas écrire dans la RAM comme il faut pour afficher mes caractères car le curseur reste à sa place et rien ne bouge.

Si quelqu'un qui aurait déjà piloter ce type d'afficheur pouvait m'aider, ce serait super !

En vous remerciant...

;*****************************************************************************
;                        VARIABLES BANQUE 0                                  *
;*****************************************************************************

; Zone de 80 bytes
; ----------------

    CBLOCK    0x20        ; Début de la zone (0x20 à 0x6F)
    CFCHaut        : 1        ; Flag Capteur fin de course Haut
    CFCBas        : 1        ; Flag Capteur fin de course Bas
    FlTempo250  : 1
    CmptTempo1  : 1
    CmptTempo2  : 1
    BclLED        : 1        ; Boucle temps allumage LED
    DonAff1        : 1        ; Octet à envoyer n°1



;*****************************************************************************
;                      DEMARRAGE SUR RESET                                   *
;*****************************************************************************

    org 0x000         ; Adresse de départ après reset
    clrf    PCLATH          ; Effacer sélecteur de pages
      goto    init        ; Initialiser

; ////////////////////////////////////////////////////////////////////////////

;                           P R O G R A M M E

; ////////////////////////////////////////////////////////////////////////////

;*****************************************************************************
;                          INITIALISATIONS                                   *
;*****************************************************************************

init

            ; initialisation PORTS (banque 0 et 1)
            ; ------------------------------------
    BANK0            ; sélectionner banque0
    clrf    PORTA        ; Sorties PORTA à 0
    clrf    PORTB        ; sorties PORTB à 0
    clrf    PORTC        ; sorties PORTC à 0
    clrf    PORTD        ; sorties PORTD à 0
    bsf    STATUS,RP0    ; passer en banque1
    movlw    ADCON1VAL    ; PORTA en mode digital/analogique
    movwf    ADCON1        ; écriture dans contrôle A/D
    movlw    DIRPORTA    ; Direction PORTA
    movwf    TRISA        ; écriture dans registre direction
    movlw    DIRPORTB    ; Direction PORTB
    movwf    TRISB        ; écriture dans registre direction
    movlw    DIRPORTC    ; Direction PORTC
    movwf    TRISC        ; écriture dans registre direction
    movlw    DIRPORTD    ; Direction PORTD
    movwf    TRISD        ; écriture dans registre direction
    movlw    DIRPORTE    ; Direction PORTE
    movwf    TRISE        ; écriture dans registre direction


            ; Registre d'options (banque 1)
            ; -----------------------------
    movlw    OPTIONVAL    ; charger masque
    movwf    OPTION_REG    ; initialiser registre option

            ; registres interruptions (banque 1)
            ; ----------------------------------
    movlw    INTCONVAL    ; charger valeur registre interruption
    movwf    INTCON        ; initialiser interruptions
    movlw    PIE1VAL        ; Initialiser registre 
    movwf    PIE1        ; interruptions périphériques 1
    movlw    PIE2VAL        ; initialiser registre
    movwf    PIE2        ; interruptions périphériques 2
    movlw    CVRCONVAL    ; charger la valeur du registre pour VREF
    movwf    CVRCON        ; initialiser le registre
    movlw    CMCONVAL    ; charger la valeur du registre des comparateurs
    movwf    CMCON        ; initialiser le registre


            ; Effacer RAM banque 0
            ; ---------------------
    bcf    STATUS,RP0    ; sélectionner banque 0
    movlw    0x20        ; initialisation pointeur
    movwf    FSR        ; d'adressage indirect
init1
    clrf    INDF        ; effacer ram
    incf    FSR,f        ; pointer sur suivant
    btfss    FSR,7        ; tester si fin zone atteinte (>7F)
    goto    init1        ; non, boucler

            ; autoriser interruptions (banque 0)
            ; ----------------------------------
    clrf    PIR1        ; effacer flags 1
    clrf    PIR2        ; effacer flags 2
    bsf    INTCON,GIE    ; valider interruptions
;    goto    start        ; programme principal

    
;                Initialisation Liaison série pour Afficheur      
;         -------------------------------------------
    BANK1
    movlw    B'10000000'    ; CKE=0
    movwf    SSPSTAT        ; 
    BANK0
    movlw    B'00110010'    ; Liaison MSSP en service - 
    movwf    SSPCON        ; CKP=1 Fquartz/64
    
    call    Tempo250ms    ; Tempo nécessaire à l'initialisation
    
    movlw    B'11111000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'00110000'    ; Ouvre Fonctions basiques (RE=0) + Interfaçage 8 bits
    movwf    DonAff1        ;
    call    Send        ;  
    movlw    B'00000000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    call    Tempo100us    ;
    
    movlw    B'11111000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'00000000'    ; Dispay ON - Cursor OFF - Character BLINK OFF
    movwf    DonAff1        ;
    call    Send        ;  
    movlw    B'11110000'    ;
    movwf    DonAff1    ;
    call    Send        ;
    call    Tempo100us    ;
    
    movlw    B'11111000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'00000000'    ; Clear Display
    movwf    DonAff1        ;
    call    Send        ;  
    movlw    B'00010000'    ;
    movwf    DonAff1    ;
    call    Send        ;
    call    Tempo250ms    ;
    
    movlw    B'11111000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'00000000'    ; 
    movwf    DonAff1        ; Entry Mode Set
    call    Send        ;  
    movlw    B'01100000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    call    Tempo100us    ;
    
    movlw    B'11111000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'00000000'    ; 
    movwf    DonAff1        ; Return Home
    call    Send        ;  
    movlw    B'00100000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    call    Tempo100us    ;
    
    
    goto    aff
    
    

    
    
;*********************************************************************
;                SOUS-ROUTINE TEMPO 1 de 250ms (249,564ms)      *
;*********************************************************************
Tempo250ms
    BANK0    
    movlw    0xF3        
    movwf    CmptTempo2    ; ajuster à 249,564 ms                
BclTempo2
    clrf    CmptTempo1    ; effacer compteur 2            
BclTempo1
    nop
    decfsz    CmptTempo1,f    ; décrémenter compteur1            
    goto    BclTempo1    ; si pas 0, boucler            
    decfsz    CmptTempo2,f     ; si 0, décrémenter compteur 2        
    goto    BclTempo2    ; si cmpt2 pas 0, recommencer boucle1
    return

    ;*********************************************************************
;                SOUS-ROUTINE TEMPO 1 de 100us      *
;*********************************************************************
Tempo100us
    BANK0    
    movlw    0x20        
    movwf    CmptTempo1    ; ajuster à 249,564 ms                            
BclTempo3
    decfsz    CmptTempo1,f    ; décrémenter compteur1            
    goto    BclTempo3    ; si pas 0, boucler            
    return


;*****************************************************************************
;                SOUS-ROUTINE Envoyer octet sur afficheur                                   *
;*****************************************************************************
Send
    BANK0
    bsf    CSAFF        ; sélectionner l'esclave
    call    Tempo100us
    bcf    PIR1,SSPIF    ; effacer flag fin de transmission
    movf    DonAff1,w    ; charger octet à envoyer à l'afficheur
    movwf    SSPBUF        ; lancer le transfert
sendloop1
    btfss    PIR1,SSPIF    ; tester si transfert terminé
    goto    sendloop1    ; non, attendre    
    call    Tempo100us
    bcf    CSAFF        ; désélectionner l'esclave
    return            ; et retour



;*****************************************************************************
;                      PROGRAMME PRINCIPAL                                   *
;*****************************************************************************

aff    
    movlw    B'11111000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'10000000'    ; 
    movwf    DonAff1        ; DDRAM Adress
    call    Send        ;  
    movlw    B'00000000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    call    Tempo100us    ;
    

    
    movlw    B'11111100'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'10100000'    ; 
    movwf    DonAff1        ; Write Data
    call    Send        ;  
    movlw    B'00100000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    call    Tempo100us    ;
    
    movlw    B'11111100'    ;
    movwf    DonAff1        ;
    call    Send        ;
    movlw    B'01000000'    ; 
    movwf    DonAff1        ; Write Data
    call    Send        ;  
    movlw    B'00100000'    ;
    movwf    DonAff1        ;
    call    Send        ;
    call    Tempo100us    ;
    

    
    

    goto    aff
    
    
    END

-----

[ankou29666]

Bonjour

pour moi l'assembleur pic ça remonte à loin et en plus assez difficilement lisible mais je vais tout de même tenter ma chance. J'ai remarqué plusieurs choses.

Premièrement j'ai remarqué que tu mets le chip select à 1 pour appeler ton composant et à 0 pour le désélectionner. Au départ j'ai cru que le problème venait de là, car généralement c'est le contraire, le composant est actif avec un chipselect à 0. Mais ton composant déroge à la règle et donc cette partie-ci du code est correcte. Je me permets juste de te faire la remarque pour que tu y penses à l'avenir si tu envisages d'utiliser d'autres composants sur bus SPI
Un autre truc auquel il peut être intéressant de faire attention c'est l'histoire de transmission sur front montant ou descendant de l'horloge (les modes 0 1 2 et 3). La datasheet de ce composant est vraiment digne du made in china à ce sujet.
L'un des inconvénients du bus SPI c'est qu'il manque de normalisation et parfois c'est un peu l'anarchie, chaque constructeur n'en fait un peu qu'à sa tête.

Deuxièmement, j'observe que CSAFF n'est défini nulle part, et ça logiquement ça fait planter le compilateur. Ou peut-être une erreur de copier/coller.

La troisième chose, et vraisemblablement la cause du problème, c'est que tu actives le CS, puis tu envoie un octet, tu désactives CS, tu le réactives, tu renvoies un nouvel octet, tu le redésactives.
Tu envoies l'octet de synchronisation 1111 1000, c'est une bonne chose, mais il faut envoyer la série d'octets composant l'instruction que tu souhaites faire exécuter à ton LCD, et en fin d'instruction tu désactives le chip select.

Et il faut envoyer le message d'un seul bloc. En désactivant le CS après chaque octet, le contrôleur ne reçoit que des blocs d'un octet, c'est à dire des fragments de message au lieu d'un message complet.

[damien8024]

Merci ankou29666 d'avoir pris le temps de lire mon code... Je sais que c'est pas tout le temps évident de déchiffrer celui d'un autre !

Pour répondre à tes questions :

- Pour les paramètres de transmission au niveau horloge, je pense être bon car d’après le datasheet, l'octet est lu par l'afficheur sur front montant de clk.

- CSAFF est bien déclaré, c'es tjuste que j'ai oublié de le copier/coller en essayant de mettre juste le bout de code correspondant à mon problème.

-Pour l'activation du CS, je me suis demandé ça aussi auparavant et j'avais essayé avec les bouts de code ci-dessous mais rien que pour l'initialisation de l'afficheur, ça affiche plein de pixels partout (comme dans :

source : https://user-images.githubuserconten...ce2aa61c7.jpeg).

Mais sans doute que je me suis planté quelque part !

;                Initialisation Liaison série pour Afficheur      
;		 -------------------------------------------
	BANK1
	movlw	B'10000000'	; CKE=0
	movwf	SSPSTAT		; 
	BANK0
	movlw	B'00110010'	; Liaison MSSP en service - 
	movwf	SSPCON		; CKP=1 Fquartz/64
	
	call	Tempo250ms	; Tempo nécessaire à l'initialisation
	
	movlw	B'11111000'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'00110000'	; Ouvre Fonctions basiques (RE=0) + Interfaçage 8 bits
	movwf	DonAff2		;
	call	Send		;  
	movlw	B'00000000'	;
	movwf	DonAff3		;
	call	Send		;
	call	Tempo100us	;
	
	movlw	B'11111000'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'00000000'	; Dispay ON - Cursor OFF - Character BLINK OFF
	movwf	DonAff2		;
	call	Send		;  
	movlw	B'11110000'	;
	movwf	DonAff3	;
	call	Send		;
	call	Tempo100us	;
	
	movlw	B'11111000'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'00000000'	; Clear Display
	movwf	DonAff2		;
	call	Send		;  
	movlw	B'00010000'	;
	movwf	DonAff3	;
	call	Send		;
	call	Tempo250ms	;
	
	movlw	B'11111000'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'00000000'	; 
	movwf	DonAff2		; Entry Mode Set
	call	Send		;  
	movlw	B'01100000'	;
	movwf	DonAff3		;
	call	Send		;
	call	Tempo100us	;
	
	movlw	B'11111000'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'00000000'	; 
	movwf	DonAff2		; Return Home
	call	Send		;  
	movlw	B'00100000'	;
	movwf	DonAff3		;
	call	Send		;
	call	Tempo100us	;
	
	
	goto	aff

;*****************************************************************************
;                SOUS-ROUTINE Envoyer octet sur afficheur                                   *
;*****************************************************************************
Send
	BANK0
	bsf	CSAFF		; sélectionner l'esclave
	call	Tempo100us
	bcf	PIR1,SSPIF	; effacer flag fin de transmission
	movf	DonAff1,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop1
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop1	; non, attendre
	movf	DonAff2,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop2
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop2	; non, attendre	
	movf	DonAff3,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop3
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop3	; non, attendre		
	call	Tempo100us
	bcf	CSAFF		; désélectionner l'esclave
;	clrf	DonAff1
;	clrf	DonAff2
;	clrf	DonAff3
	return			; et retour


;*****************************************************************************
;                      PROGRAMME PRINCIPAL                                   *
;*****************************************************************************
aff
	movlw	B'11111100'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'10100000'	; 
	movwf	DonAff2		; Write Data
	call	Send		;  
	movlw	B'00100000'	;
	movwf	DonAff3		;
	call	Send		;
	call	Tempo100us	;
	
	movlw	B'11111100'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'01000000'	; 
	movwf	DonAff2		; Write Data
	call	Send		;  
	movlw	B'00100000'	;
	movwf	DonAff3		;
	call	Send		;
	call	Tempo100us	;
	
	end

[ankou29666]

Merci ankou29666 d'avoir pris le temps de lire mon code... Je sais que c'est pas tout le temps évident de déchiffrer celui d'un autre !

Pour répondre à tes questions :

- Pour les paramètres de transmission au niveau horloge, je pense être bon car d’après le datasheet, l'octet est lu par l'afficheur sur front montant de clk.

- CSAFF est bien déclaré, c'es tjuste que j'ai oublié de le copier/coller en essayant de mettre juste le bout de code correspondant à mon problème.

-Pour l'activation du CS, je me suis demandé ça aussi auparavant et j'avais essayé avec les bouts de code ci-dessous mais rien que pour l'initialisation de l'afficheur, ça affiche plein de pixels partout (comme dans ce lien : https://user-images.githubuserconten...ce2aa61c7.jpeg).

Mais sans doute que je me suis planté quelque part !

	movlw	B'11111000'	;
	movwf	DonAff1		;
	call	Send		;
	movlw	B'00000000'	; Dispay ON - Cursor OFF - Character BLINK OFF
	movwf	DonAff2		;
	call	Send		;  
	movlw	B'11110000'	;
	movwf	DonAff3	;
	call	Send		;
	call	Tempo100us	;

Que penses tu des deux lignes que j'ai mis en rouge ?

[A voir en vidéo sur Futura]

[damien8024]

Oups j'avais oublié de les désactiver effectivement !

En ayant réessayer, j'ai toujours le même affichage plein de pixels sauf que maintenant je ne vois même plus mon curseur qui clignote.
Alors que juste avant, il était quand même affiché dans ce bazar de pixels...

Pour précision, j'avais le même écran juste aprés une activation du mode "Graphic Display" lors de mes précédents tests.

[damien8024]

Oups effectivement j'avais oublié de les supprimer !

Après avoir essayé sans ces lignes, l'afficheur m'affiche la même chose mais sans le curseur qui clignote alors que j'arrivais à le distinguer juste avant.

Pour précision, j'avais eu le même écran juste après activation mode graphique de l'afficheur lors de mes précédents test.

[ankou29666]

;                Initialisation Liaison série pour Afficheur      
;         -------------------------------------------
    BANK1
    movlw    B'10000000'    ; CKE=0
    movwf    SSPSTAT        ; 
    BANK0
    movlw    B'00110010'    ; Liaison MSSP en service - 
    movwf    SSPCON        ; CKP=1 Fquartz/64
    
    call    Tempo250ms    ; Tempo nécessaire à l'initialisation

Donc si je comprends bien, tu as réglé l'horloge du bus SPI à celle de l'horloge du PIC divisée par 64 ? à quelle vitesse le pic est-il cadencé ?

[damien8024]

Le pic est cadencé à 4 MHz

J'avais cadencé à l'horloge du bus spi à celle du pic divisé par 4 au début, d'où cette valeur pour tester si cas où...

Je viens de réessayer avec celle du début mais pareil...

Ce qui est étrange, c'est que l'initialisation fonctionnait en envoyant les octets comme au début, c'est à dire en exécutant ma sous-routine octet par octet (je précise que j'avais essayé de laisser le CS à 1 tout le temps vu qu'il n'y a que cet afficheur en liaison série pour le moment mais ça ne changeait rien)

Si on considère que mon code était bon (je n'en sais rien), cela voudrait dire que c'est seulement l'écriture en ram que je fais pas comme il faut. La doc parle de deux octets à écrire à la suite (2 caractères ASCII) mais j'avais essayé et le curseur ne bougeait pas non plus.

Si j'ai bien compris le fonctionnement de l'afficheur, on l'initialise, on pointe une adresse de la ddram pour placer le curseur puis on écrit deux octets ?

[ankou29666]

d'accord.

est-ce que tu as viré mes deux lignes dans chaque bloc ? ou uniquement pour celui que j'ai indiqué ? (il y a le même problème partout et je ne l'ai indiqué qu'une seule fois).

sinon en vitesse de bus, ça donne 62.5kHz, de ce que j'ai compris de la datasheet on devrait pouvoir monter à 1.6MHz (c'est un peu déconcertant pour un composant qui n'est cadencé qu'à 600kHz au maximum mais soit) donc normalement le problème ne doit pas venir de là.

là qu'on entre dans des trucs que j'aime pas trop, c'est que ce composant fonctionne avec une liaison série qui ressemble assez fort à une liaison SPI, mais qui ne prétend pas être un bus SPI. pourtant à priori j'ai envie de dire qu'on est bon mais ça m'inquiète un peu quand même.

[damien8024]

Oui j'avais bien virer mes lignes fausses partout...

Tu penses donc qu'il y ai une possibilité que la liaison spi n'ai pas exactement le même protocole que celle du pic ?

[ankou29666]

je n'en suis pas convaincu. J'ai trouvé un peu de documentation chez un revendeur qui lui parle de SPI et fourni aussi bien la doc du module qu'il vend que celle du composant autour duquel s'articule le module.

Si le module que tu as est identique à celui que j'ai trouvé, il doit y avoir une broche qui permet de sélectionner le mode série ou parallèle. Qu'as tu fait à ce niveau là ?

[ankou29666]

d'ailleurs, histoire qu'on parte sur les mêmes bases, est-ce que tu peux nous poster les datasheets que tu utilises stp ?

[damien8024]

En ce qui concerne la doc, j'utilise celle du controlleur et celle de mon afficheur qui est un HJ12864ZW (Afficheur hj12864zw.pdf)

Pour la broche qui permet de choisir le mode, je l'ai relié à la masse (Broche RS n°4)

[damien8024]

Et pour le contrôleur j'avais trouvé celle-ci :
Afficheur st7920.pdf

[damien8024]

Je voulais dire la broche PSB (n°15) !

[ankou29666]

ok donc on est bien en mode série. Par contre je crois déceler une erreur dans l'instruction entry mode.

En revanche, tu dis ne pas connaitre le C, je ne peux que t'inviter à t'y mettre car tu remarqueras vite que tout devient nettement plus lisible, et que ça permet de débugger bien plus facilement.

[damien8024]

Oui effectivement, il faudrait que je m'y mette mais c'est tout un langage à apprendre... Il faudra bien que je le fasse ceci dit !

Je regardais ma doc et je reviens sur ce que t'avais évoqué, la fréquence du bus. Je vois sur le datasheet qu'elle doit être entre 470 KHz et 590 KHz.
Je me disais que vu que ma fréquence de clk réglé par le pic est de soit de 250 KHz (4Mhz/16) ou 1MHz (4MHz/4), on est pas dans la range de l'afficheur.
Donc est ce que les essais précédents d'envoyer tous les octets en même temps, comme il semble le plus logique, ne fonctionnaient pas car on se désynchronise au bout d'un moment ?

[ankou29666]

Le C en soit n'est pas compliqué, c'est vrai que c'est tout un langage à apprendre mais ça reste quand même plus simple que l'assembleur et visuellement plus causant, plus proche du langage naturel.

Pour l'entry mode je ne comprends pas trop, car selon la page 18 (en haut) de la datasheet, ça propose un dernier bit à zéro alors qu'en bas de page suivante elle est indiquée à un. Sans véritable explication sur ce que signifie ce dernier bit.

Pour l'horloge il faut faire la distinction entre le fonctionnement du bus de communication et le fonctionnement de l'afficheur lui même. C'est juste un problème psychiatrique : mon cerveau bug car il n'est pas habitué à ce que la fréquence d'horloge d'un bus puisse être fréquence plus élevée que celle de fonctionnement du composant lui même.

Ici point de désynchronisation, puisque le bus est synchronisé par une horloge. D'ailleurs je ne comprends pas les bouffées délirantes aiguës des développeurs de la puce avec leur octet de synchronisation. en SPI c'est le rôle du CS que de signaler le début de message. ça ne peut pas se désynchroniser. Ni celle de passer demi-octet par demi-octet, ça n'a aucun sens. (Et d'ailleurs d'autres bus comme les UART disposent aussi de mécanisme de synchronisation alors qu'ils n'ont pas d'horloge. Mais uniquement pour les octets, pas pour les débuts et fin de message où là il n'y a rien de prévu sur les couches matérielles. En mode texte il y a les classiques retours chariots pour signaler la fin du message, ce qui signifie que la suite est un nouveau message. En mode binaire, c'est plus délicat. A se demander si ça n'aurait pas été développé par quelqu'un qui serait familier des UART et pas du SPI tellement ça aurait un sens dans le cas d'une UART.)

[damien8024]

Alors en utilisant le réglage du PIC pour avoir une fréquence de bus en fonction du Timer2, j'arrive à une fréquence de 500 KHz (Timer2/4 et on redivise par 2 dans le réglage du registre).

Je viens de modifier mon code avec ces paramètres et j'envoie les octets à la suite sans pause. Mon initialisation se passe désormais bien !
Donc tu avais raison sur la manière d'envoyer les données, c'était juste à cause de la fréquence du bus hors plage.

Ceci dit, je n'arrive toujours à rien afficher....
J'ai essayé en envoyant qu'un octet pour un caractère et deux octets pour deux caractères à la suite.
Pour un octet envoyé, mon curseur disparaît et pour deux octets envoyés à la suite, le curseur ne bouge pas.

	movlw	B'11111100'	;
	movwf	DonAff1		;
	movlw	B'10100000'	; 
	movwf	DonAff2		; Write Data
	movlw	B'00100000'	;
	movwf	DonAff3		;	
        movlw	B'01000000'	; 
	movwf	DonAff4		; Write Data
	movlw	B'00100000'	;
	movwf	DonAff5		;
	call	Send		;
	call	Tempo100us	;

[damien8024]

Et pour ma routine d'envoie :

;*****************************************************************************
;                SOUS-ROUTINE Envoyer octet sur afficheur                                   *
;*****************************************************************************
Send
	BANK0
	bsf	CSAFF		; sélectionner l'esclave
	call	Tempo100us
	bcf	PIR1,SSPIF	; effacer flag fin de transmission
	movf	DonAff1,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop1
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop1	; non, attendre
	movf	DonAff2,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop2
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop2	; non, attendre	
	movf	DonAff3,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop3
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop3	; non, attendre	
	btfss	DonSup,0	; tester si deuxième octet à envoyer à la suite pour écrire dans RAM Afficheur
	return
	movf	DonAff4,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop4
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop4	; non, attendre	
	movf	DonAff5,w	; charger octet à envoyer à l'afficheur
	movwf	SSPBUF		; lancer le transfert
sendloop5
	btfss	PIR1,SSPIF	; tester si transfert terminé
	goto	sendloop5	; non, attendre		
	call	Tempo100us
	bcf	CSAFF		; désélectionner l'esclave
	clrf	DonAff1
	clrf	DonAff2
	clrf	DonAff3
	clrf	DonAff4
	clrf	DonAff5
	
	return			; et retour

[Qristoff]

Salut,
Quel environnement de programmation utilises tu ?
Dans MPLab, tu as la possibilité de tester ton code en utilisant l'analyseur logique intégré (mode debug). Tu peux faire une simulation pour vérifier que tes signaux correspondent bien à ce qu'attend le contrôleur par rapport à sa datasheet.

[damien8024]

Bonjour ankou29666,

Dsl, je n'avais pas vu ta réponse hier soir...

Pour l'Entry Mode, d’après ce que je comprends du datasheet, le dernier bit (S) correspondrait au défilement de l'écran. A 0, pas de défilement (l'écran reste figé sur ces 16 caractères) alors que si on le mets à 1, l'ecran se décale dans le sens logique du déplacement du curseur configuré par le bit I/D.

Effectivement, je dois confondre la fréquence d’oscillation de l'afficheur et celle du bus. Ceci dit c'est étrange que maintenant j'arrive à envoyer mes octets par 3 (RS et RW + Bits pois fort + Bits poids faible) en un seul envoie et en réussissant à initialiser mon afficheur correctement.

C'est vrai que je n'avais pas moi-même compris l'histoire des 5 bits de start vu qu'on est sur une liaison SPI synchrone. Ni celle des demi-octets d'ailleurs !
Je n'ai jamais expérimenté l'UART mais si j'ai bien compris, on envoie les bits dans l'autre sens et on peut s'en servir en liaison synchrone ou asynchrone ?

[damien8024]

Salut Qristoff,

J'utilise MPLab IDE et effectivement ça serait pas mal que je simule mon programme avec l'analyseur logique...
Le soucis c'est qu'il tourne en boucle dans ma routine au moment du test du flag de bit de fin de transmission du module SPI. Il reste toujours figé à 0 mais je n'avais pas chercher plus que ça non plus... A creuser !

[damien8024]

Il y a quelque chose qui me chagrine depuis le début et que je n'arrive pas à comprendre...

Le datasheet me dit que si je veux switcher entre Basic instructions et Extended instruction, il fait changer le bit RE de Function Set ou extended function set.
Or le descriptif de la fonction Extended Function Set dit qu'on ne peut changer les bits DL, RE et G en même temps. Ce qui oblige à envoyer deux fois la fonction.
Mais pourquoi ça dit qu'il faut d'abord changer DL ou G puis RE ? Ce serait plus logique de changer d'abord RE pour dire que je passe en mode Extended Function Set puis je change mon bit G pour activer le mode graphique.

[ankou29666]

je crois que les concepteurs de ce composant ont leurs raisons que la raison ignore.
Comme je l'ai dit l'octet de synchro est un non sens sur un bus SPI (mais aurait été sensé sur une UART), et envoyer un octet en deux temps n'en a pas non plus. Le Chip Select inversé c'est original aussi.

[Qristoff]

D'après la datasheet, si la liaison entre ton pic et ton contrôleur est unique (pas d'autre abonné sur le bus), tu peux mettre le CS en permanence à 1. Ainsi, il n'y a que SCLK et SID à gérer dans un premier temps.
Ensuite, il est indiqué qu'il ne doit pas y avoir que 24 coups d'horloge, pas un plus ou moins ! et que le contrôleur récupère le bit sur front montant.
Il faut déja vérifier tout ça à l'analyseur !

[Qristoff]

Encore moi, je pense savoir d’où viens le problème. Un octet doit être envoyé dans deux octets avec le quartet Msb dans le premier octet et le quartet Lsb dans le deuxième octet.
Je suis d'accord, ça fait un peu de gymnastique...
Donc, un cycle d'envoi comporte trois octets, 1 octet de synchro, le 1er octet comportant le quartet Msb et le second octet comportant le quartet Lsb de l'octet à transmettre. voir la figure de la page 7 de la DS.
Du coup, je pense que tu ne peux pas utiliser lebloc SSP du pic.

[damien8024]

Pour le CS tout le temps à 1, effectivement j'avais vu ça aussi et j'avais testé dans ce sens.
Pour les 24 coups d’horloge, ça par contre, je n'avais pas fait attention ! Le problème c'est que je n'ai pas vraiment moyen de contrôler ça ? A moins que chaque coup d’horloge corresponde réellement à 1 bit ?

Donc tu penses que module SSP ne suive pas exactement le protocole demandé, y a t-il un autre moyen de communiquer en série ?

Je viens de terminer la transformation de mon montage et de mon code pour une liaison parallèle 8 bits...
C'est beaucoup mieux car pour l'instant j'initialise mon afficheur et j'affiche un caractère même si ce n'est pas celui voulu et que je n'arrive pas à mon positionner mon curseur où je veux.
Mais ça c'est du à mon manque de connaissance en afficheur donc je vais chercher et tenter de mieux comprendre le data sheet !

Je vais essayer de mieux maîtriser les protocoles de mon afficheur dans ce mode plus simple avant de me repencher sur cette liaison série...

Sinon je te remercie beaucoup de m'avoir consacré du temps car même si ce n'est pas résolu (sauf si c'est vraiment une incompatibilité du SSP), tu m'as quand même permis d'avancer !

[MathSACO]

Bonjour.

As-tu essayer d'ajouter :

        bcf	PIR1,SSPIF	; effacer flag fin de transmission

avant :

	movf	DonAff2,w	; charger octet à envoyer à l'afficheur

et avant :

	movf	DonAff3,w	; charger octet à envoyer à l'afficheur

[damien8024]

Ah oui effectivement c'est bien vu ! Un oubli de ma part...

C'est clair que ça fausse la transmission des 3 octets à la suite sans effacer ce flag !

Je vais corriger ça et voir... Merci