Répondre à la discussion
Affichage des résultats 1 à 15 sur 15

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



  1. #1
    MiKL.66

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

    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

    -----


  2. Publicité
  3. #2
    MiKL.66

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

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

  4. #3
    mica25000

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

    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

  5. #4
    MiKL.66

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

    Salut,

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

  6. #5
    mica25000

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

    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
    Code:
    #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

  7. A voir en vidéo sur Futura
  8. #6
    MiKL.66

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

    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

  9. Publicité
  10. #7
    mica25000

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

    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

  11. #8
    MiKL.66

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

    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

  12. #9
    MiKL.66

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

    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 ...
    Dernière modification par MiKL.66 ; 03/08/2013 à 18h30.

  13. #10
    MiKL.66

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

    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)

  14. #11
    MiKL.66

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

    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);
    }

  15. #12
    MiKL.66

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

    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

  16. Publicité
  17. #13
    MiKL.66

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

    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

    ...

  18. #14
    MiKL.66

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

    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.

  19. #15
    MiKL.66

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

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

Sur le même thème :

Discussions similaires

  1. [PIC24-Module ECAN]- Aide à la mise en oeuvre d'un bus CAN
    Par jorg1n dans le forum Électronique
    Réponses: 7
    Dernier message: 08/10/2012, 09h44
  2. Gestion d'un afficheur lcd 4x20 avec pic18f4550
    Par demonkyuubi dans le forum Électronique
    Réponses: 20
    Dernier message: 23/12/2011, 17h52
  3. Interconnections PIC24 / EEPROM / CAN 12 bits via bus SPI
    Par jorg1n dans le forum Électronique
    Réponses: 6
    Dernier message: 15/12/2011, 15h56
  4. Gestion d'un bus I2C avec un microcontrôleur PIC18F452
    Par Donnelalerte dans le forum Électronique
    Réponses: 6
    Dernier message: 12/09/2010, 09h32
  5. Gestion d'un afficheur avec un PIC
    Par Patou le fou dans le forum Électronique
    Réponses: 3
    Dernier message: 08/12/2005, 21h28