Gestion d'un afficheur Displaytech 64128 avec PIC24 et bus SPI

[invite66c1ab93]

Bonjour à tous,

Je commence un projet avec un afficheur graphique Displaytech 64128K.
Le micro est un PIC24FJ128GA010.
La liaison est le bus SPI.

J'arrive à afficher des caractères sans problème, mais uniquement sur les lignes correspondants aux pages 0 à 7.
Je voudrais pouvoir afficher un caractère à l'endroit que je veux, par exemple entre 2 pages.

J'ai pensé à créer un tableau qui contiendrai tous les pixels, puis écrire sur ce tableau à l'endroit souhaité et enfin transférer ce tableau vers l'afficheur.
Dans ce cas, je n'aurais plus de problème avec les pages !
Mais je ne pense pas que ce soit la bonne solution, car trop de code !!

Comment faites vous ?
Avez vous une autre astuce ?

Merci d'avance.
Mickael
-----

[invite66c1ab93]

Il n'y a personne pour me donner une autre piste ?

[invite831b139b]

Salut,

En ce qui concerne l'écriture entre deux pages il n'y a a mon avis pas d'autres solutions que de le faire pixel par pixel.
Tu peux peut être procéder autrement et faire quelque chose de "plus simple" en créant chaque symbole (lettre, nombre, caractères spéciaux ou peu importe quelle forme) pixel par pixel mais en prenant en compte les coordonnées.
en admettant un carré de 2 pixels / 2 pixels :

pixel_1 (0+x,0+y)
pixel_2 (1+x,0+y)
pixel_2 (0+x,1+y)
pixel_2 (1+x,1+y)

chaque pixel a une position fixe par rapport aux 3 autres (ce qui permet de conserver la forme), mais l'ensemble peut bouger librement.

Sinon j'essaie moi aussi d'utiliser ce même écran en SPI mais avec un PIC18F46k22, mais je ne parviens pas à écrire quelque chose dessus, et je n'ai pas d'oscillo donc je peux même pas voir ce qui se passe sur ma ligne...
Est-ce que tu pourrais me transmettre un bout de code qui me permettrait de le faire fonctionner? merci

[invite66c1ab93]

Salut,

Je veux bien te passer le code, mais quel est ton compilateur ?

[A voir en vidéo sur Futura]

[invite831b139b]

Salut! bon rectification, j'arrive à afficher des trucs, mais je ne comprends toujours pas comment on définit là où on veut écrire...
j'utilise CCS et MPLAB, et même si c'est un autre compilateur, tant que c'est du C je dois pouvoir me débrouiller

voilà mon code, ce sera plus simple pour m'aider je pense

#include <main.h>
#USE SPI (MASTER, SPI1, CLOCK_HIGH=1, CLOCK_LOW=1, MODE=0, BITS=8, STREAM=SPI_1)
void send_command (int command)
   {
   output_low (A0);
   output_low (CS);
   spi_write (command); // 8 bits
   output_high (CS);
   output_high (A0);
   }

void send_data (int data)
   {
   output_high (A0);
   output_low (CS);
   spi_write (data); // 8 bits
   output_high (CS);
   output_high (A0);
   }
   
void init_lcd (void)
   {
   output_high (BACKLIGHT);
   output_high (A0);
   output_low (RST);
   output_high (RST);
   send_command (0x40);
   send_command (0xA0);
   send_command (0xC8);
   send_command (0xA6); // 0xA6 = positive screen ; 0xA7 = negative screen
   send_command (0xA2);
   send_command (0x81); // enter contrast mode
   send_command (0x1F); // value of contrast [0..63]
   send_command (0x2F);
   send_command (0xAD);
   send_command (0x00);
   send_command (0xAF);
   send_command (0xA4);   
   send_command (0xA0);
   send_command (0x40); // return at pixel [1,1] ?
   }

void clear_lcd (void)
   {
   int x=0;
   int y=0xB0; // 0xB0 = first page, 0xB7 = 8th page?
   int clear=0;
   while (clear==0)
      {
      send_command (y);
      send_data(0x00);
      output_toggle (PIN_A0);
      x++;
      if (x==255)
         {
         y++;
         x=0;
         if (y>0xB7)
            {
            clear=1;
            }
         }
      }
   }
   
void main (void)
   {
   setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
   setup_timer_4(T4_DISABLED,0,1);
   setup_timer_5(T5_DISABLED | T5_DIV_BY_1);
   setup_timer_6(T6_DISABLED,0,1);
   port_b_pullups (TRUE);

   init_lcd ();
   clear_lcd ();
   output_high (PIN_A1); // LED_GREEN
   output_high (PIN_A2); // LED_YELLOW_1
   output_high (PIN_A3); // LED_YELLOW_2
   send_command (0xB0);
   while(TRUE)
      {
      send_data (0x81);
      output_toggle (PIN_A0); // toggle LED_RED
      delay_ms (500);
      }
   }

logiquement en envoyant 0x81 je devrais avoir 2 points qui s'affichent à la première colonne de la première page, mais au lieu de ça il commence n'importe où sur la première page et avance au fur et à mesure jusqu'à tracer 2 lignes continues...

merci, une fois que j'aurai compris ça j'essaierai de voir comment écrire entre 2 pages

[invite66c1ab93]

Ah ... ce fameux logiciel CCS !
J'ai commencé également avec ce logiciel et aujourd'hui je le regrette pour des raisons qui seraient trop long à expliquer.
Aujourd'hui, Microchip propose des logiciels gratuits ... XC8, XC16, XC32 ...

Pourquoi utiliser les "merdes" comme CCS, MikroC, ... !!!
Je peux prouver concrètement les limites de ces logiciels.
Ces logiciels sont très facile à prendre en main, mais en progressant ... vous vous rendez compte des limites ... et après, pour changer c'est une autre histoire.

Revenons à nos moutons ...
Je suis actuellement sur un projet lourd, dès que je termine je me penche sur ton programme et te tiens au courant.

Mickael

[invite831b139b]

Bonjour,
d'accord avec vous en ce qui concerne CCS, mais c'est le logiciel qu'on a au lycée... j'utilise aussi C18 et il m'arrive parfois de programmer un Arduino en lignes de commandes sous Linux, donc en ce qui concerne l'environement je n'ai pas trop de problèmes

ce qui m'intéresse c'est vraiment les commandes à envoyer pour pouvoir positionner le "curseur" où je veux comme les afficheurs 2 lignes 16 caractères par exemple.

Pas de problème ce n'est pas très urgent. Merci beaucoup

[invite66c1ab93]

Bonjour à tous,

Je me suis remis sur ce projet depuis environ 2 semaines.
Je n'ai pas encore trouvé de solutions pour ma demande initiale, mais comme j'ai eu quelques demandes d'aide sur cet afficheur et je souhaitais reprendre ce post pour faire profiter au plus grand nombre.
Je vais poster au fur et à mesures de mon avancé.
Désolé pour ceux qui sont impatient, mais j'ai beaucoup de travail et je fais comme je peux.

J'ai voulu faire un exemple avec un PIC18, mais je n'y suis pas arrivé (je connais mal les 8 bits).
Le code sera portable pour la majorité des PIC24.
J'utilise finalement le PIC24FJ64GA004.

Je vais bien sûre donner le code partiellement, uniquement pour l'écran.
Mon projet est assez complet, il comporte :
- une face avant avant 4 boutons directionnelles ainsi qu'un bouton "OK" et "ESC" afin de pouvoir naviguer dans le menu
(il en a qui vont se dire pourquoi ne pas avoir choisis un écran tactile, je donne de suite la réponse : milieu industriel avec des brutes, gants, poussières, jets d'eau, etc ...)
- ADC 2 canaux 12bits bus SPI
- 2 entrées 4-20mA isolées
- 1 sortie 4-20mA isolée
- EEPROM 4k BUS I2C
- Horloge temps réel I2C MCP79410
- Communication MODBUS RTU pour piloter des variateurs ou transmission vers GTC type Sofrel ou autres
- Communication Uart avec GSM Sim900 (transmission de SMS et connexion sur serveur Web)
- Communication radio 433Mhz (SPI) pour récupération de données sur compteurs déportés
- I/O expander 8 bits bus I2C
- entrées TOR
- Sorties relais

Mickael

[invite66c1ab93]

En attendant mon avancé, voici ce qui me chagrine ...
J'affiche les caractères avec ce tableau (7 pixels (+1) de haut et 5 pixels (+1) de larges) :
const unsigned char FONT[][6] =
{
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // sp
{ 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 }, // !
{ 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 }, // "
{ 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 }, // #
{ 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, // $
{ 0x00, 0x62, 0x64, 0x08, 0x13, 0x23 }, // %
{ 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 }, // &
{ 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 }, // '
{ 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 }, // (
{ 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 }, // )
{ 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 }, // *
{ 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 }, // +
{ 0x00, 0x00, 0x00, 0x50, 0x30, 0x00 }, // ,
{ 0x00, 0x08, 0x08, 0x08, 0x08, 0x08 }, // -
{ 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 }, // .
{ 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 }, // /
{ 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E }, // 0
{ 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 }, // 1
{ 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 }, // 2
{ 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 }, // 3
{ 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 }, // 4
{ 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 }, // 5
{ 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 }, // 6
{ 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 }, // 7
{ 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 }, // 8
{ 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E }, // 9
{ 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 }, // :
{ 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 }, // ;
{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 }, // <
{ 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 }, // =
{ 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 }, // >
{ 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 }, // ?
{ 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E }, // @
{ 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C }, // A
{ 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 }, // B
{ 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 }, // C
{ 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C }, // D
{ 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 }, // E
{ 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 }, // F
{ 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A }, // G
{ 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F }, // H
{ 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 }, // I
{ 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 }, // J
{ 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 }, // K
{ 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 }, // L
{ 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F }, // M
{ 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F }, // N
{ 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E }, // O
{ 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 }, // P
{ 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E }, // Q
{ 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 }, // R
{ 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 }, // S
{ 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 }, // T
{ 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F }, // U
{ 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F }, // V
{ 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F }, // W
{ 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 }, // X
{ 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 }, // Y
{ 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 }, // Z
{ 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 }, // [
{ 0x00, 0x04, 0x08, 0x10, 0x20, 0x40 }, // /
{ 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 }, // ]
{ 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 }, // ^
{ 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 }, // _
{ 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 }, // '
{ 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 }, // a
{ 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 }, // b
{ 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 }, // c
{ 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F }, // d
{ 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 }, // e
{ 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 }, // f
{ 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C }, // g
{ 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 }, // h
{ 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 }, // i
{ 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 }, // j
{ 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 }, // k
{ 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 }, // l
{ 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 }, // m
{ 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 }, // n
{ 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 }, // o
{ 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 }, // p
{ 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC }, // q
{ 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 }, // r
{ 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 }, // s
{ 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 }, // t
{ 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C }, // u
{ 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C }, // v
{ 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C }, // w
{ 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 }, // x
{ 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C }, // y
{ 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 }, // z
{ 0x00, 0x08, 0x36, 0x41, 0x41, 0x00 }, // {
{ 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00 }, // |
{ 0x00, 0x41, 0x41, 0x36, 0x08, 0x00 }, // }
{ 0x00, 0x02, 0x04, 0x02, 0x01, 0x02 } // ~
};

... Quelqu'un aurait il un code pour afficher des caractère plus gros, par exemple sur 2 lignes ?
Je pense à 14 pixels (+2) de haut et 10 pixels (+2) de large !

Ou si quelqu'un connait un petit logiciel pour générer les fonts ...

[invite66c1ab93]

Bonsoir à tous,

Comme promis, je vais commencer à vous envoyer le code pour la gestion de l'afficheur.
Je continuerai à alimenter ce post au fur et à mesures de mon avancé.
Je vais essayé d'être le plus clair possible.

Pour commencer, voici la partie pour la gestion du module SPI :
unsigned char writeSPI2 (unsigned char i)
{
SPI2BUF = i; // write to buffer for TX
while (!SPI2STATbits.SPIRBF); // wait for transfer to complete
return SPI2BUF; // read the received value
}//writeSPI2

void SPI2INTInit ()
{
IFS2bits.SPI2IF = 0; // clear interrupt flag
IEC2bits.SPI2IE = 1; // enable interrupt
SPI2CON1 = 0b000000100100011; // select 8-bit master mode, CKE=1, CKP=0
SPI2STAT = 0x8000; // enable SPI port, clear status
} // SPI2INTInit

Je rappelle que tout le code est fonctionnel, et comme je l'avais dit plus haut, ce code est pour le µC PIC24FJ64GA004.
Il n'y aura que cette partie que vous devrait adapter à votre PIC ou à votre compilateur.
Le compilateur que j'utilise est MPLAB C30 V3.25 (MPLAB IDE V8.91)

[invite66c1ab93]

Et voici le code dans le main :
int main(void)
{
IOInit(); // Initialize Input / Output
SPI2INTInit(); // Initialize SPI module

GLCD_Reset = 0;
delayms(50);
GLCD_Reset = 1;
delayms(100);
GLCD_CS = 1;
delayms(10);
GLCD_ComData = 1;
delayms(10);
initLCDM (); // Initialize Display
delayms(10);
CLR_ALL (); // Clear dispay

GOTO_XY (0,0);
SdTexte ("TEST D'UN"); // première ligne

GOTO_XY (0,1);
SdTexte ("AFFICHEUR DISPAYTECH"); // 2ème ligne

GOTO_XY (0,2);
SdTexte ("1234567890"); // 3ème ligne

while(1);
}

[invite66c1ab93]

Il faut bien sûre penser à déclarer les pins :
#define GLCD_Reset PORTBbits.RB14 // RESET
#define GLCD_ComData PORTBbits.RB15 // COM/DATA
#define GLCD_CS PORTCbits.RC1 // ChipSelect GLCD

... et faire le nécessaire dans la fonction IOinit en fonction de votre µC:
void IOInit()
{
AD1PCFG = 0xffff; // Tous les pins en digital

TRISBbits.TRISB14 = 0; _LATB14 = 0; // GLCD_Reset
TRISBbits.TRISB15 = 0; _LATB15 = 0; // COM/DATA
TRISCbits.TRISC1 = 0; _LATC1 = 0; // ChipSelect GLCD
}

... et, pour en finir avec les init, voici l'init de l'afficheur :
void initLCDM(void)
{
SdCmd (0b11100010); // Reset
SdCmd (0b10100010); // set the LCD bias to 1/9th
SdCmd (0x23); // Voltage Regulator internal Resisitor ratio set(the internal resistor divider set to 3 (from 0..7))
SdCmd (0x2F); // Power Control Set( power control, all internal blocks ON )
SdCmd (0b00000011); // Electronic volume Mode set ???
SdCmd (0x40); // go back to the top left of the display
SdCmd (0x81); // Electronic volume Mode set
SdCmd (0b11111000); // Booster ratio Select Mode Set
SdCmd (0b00000000); // Booster ratio register set ???
SdCmd (0b10100000); // ADC Select( 0xa0:Normal, 0xa1:Reverse )
SdCmd (0b11001000); // Common output Mode Set
SdCmd (0b10101111); // Display ON
SdCmd (0b10100110); // Display Normal/Reverse(Permet d'inverser Blanc/noir)
SdCmd (0xA4); // Display all points (0xa4:Normal display mode, 0xa5:display all points)
}

Jusque là, je pense qu'il n'y a rien de bien compliqué !!

Il est tard, demain je bosse ...
Bonne nuit à tous

Mickael

[invite66c1ab93]

On continu avec un petite boucle delay.
void Delay (unsigned int m)
{
unsigned int v;
for(v = 0; v < m; v ++);
}
Cette boucle aurait pu être économisé, mais ça peut servir pour des tout petit délai dans le programme.


Une petite routine pour effacer tout l'écran :
void CLR_ALL()
{
unsigned char i;
for(i = 0; i < 8; i ++)
{
GOTO_XY (0,i);
CLR_LINE (i);
}
} //Permet d'éffacer tout l'écran


Une routine pour effacer une ligne :
void CLR_LINE (unsigned char ln)
{
unsigned char i;
GOTO_XY (0,ln);
for(i < 0; i < 128; i ++)
{
SdData(0b00000000);
}
} //Permet d'effacer une ligne entière


Quelques routines de positionnement :
void GOTO_X (unsigned char col)
{
SdCmd (0x10 | (col>>4));
SdCmd (0x00 | (col & 0x0F));

} //Permet de choisir la colonne de départ

void GOTO_Y (unsigned char ln)
{
SdCmd (0xB0 | (ln & 0x0F));
} //Permet de choisir la ligne de départ

void GOTO_XY (unsigned char x, unsigned char y)
{
GOTO_X (x);
GOTO_Y (y);
} //Permet de choisir la ligne et la colonne de départ

...

[invite66c1ab93]

Et pour finir ...

La routine pour envoyer les commandes :
void SdCmd (unsigned char Command)
{
GLCD_ComData = 0;
GLCD_CS = 0;
writeSPI2 (Command);
Delay (1);
GLCD_CS = 1;
Delay (1);
}


Pour envoyer un texte :
void SdTexte (char *s)
{
while (*s)
{
SdCaracter (*s ++);
}
SdData(0b00000000);
SdData(0b00000000);
} //Permet d'afficher du texte

void SdCaracter (unsigned char r)
{
unsigned char i;
for ( i = 0; i < 6; i ++ )
{
SdData (FONT [r-32] [i]);
}
} //Permet d'afficher un caractère

void SdData (unsigned char DData)
{
GLCD_ComData = 1;
GLCD_CS = 0;
writeSPI2 (DData);
Delay (1);
GLCD_CS = 1;
Delay (1);
}


Voilà, vous avez tout pour faire fonctionner l'afficheur.
Il faut bien sûre remettre tout ça dans l'ordre ou déclarer les prototypes.

[invite66c1ab93]

Bonsoir,

C'est évident pour moi, mais je préfère quand même préciser le raccordement des Pins restants sur l'afficheur :
- pins 4, 5, 15 et 28 au 0V
- pins 14 et 27 au 3,3V
- Pins 6 à 11 libres
- chacune des pins 22 à 26 doivent passer par un condo 1µF pour aller au 0V
- condo 1µF entre pins 15 et 16 un autre entre pins 20 et 21, puis un autre entre pins 20 et 21
- relier les pins 16 et 17

Je crois que c'est tout ...