MPLAB : Programmation d'un LCD avec un SPI.

[invite6374ce44]

Bonjour à tous.

J'ouvre mon deuxième topic sur ce forum, cette fois pour vous demander de l'aide niveau programmation.

En effet, je suis en train d'effectuer un stage d'une durée de deux mois, et je dois programmer des PIC en .C à l'aide de MPLAB, et je suis très clairement un novice !

Je vous expose mon problème : Le Pic est posé sur une carte de développement, l'Explorer 8 ( http://www.microchip.com/promo/explo...elopment-board pour + de détails), et sur cette fameuse carte de développement, il y a un écran LCD 16*2 qui est déjà monté dessus.

En regardant de plus près la documentation, je me rends compte qu'il est relié à un SPI (si je ne me trompe pas) et je ne sais pas du tout comment le piloter ..
(J'ai déjà essayer de piloter un LCD via mon Pic sans SPI et j'avais réussi après 2/3 recherches sur Google )

Je voulais donc savoir si quelqu'un aurait des bases de codes ou des explications à me fournir, je vous en remercie d'avance !

(Je programme avec MPLAB 4.15, compilateur XC8 1.45 et je travaille avec un PIC 18F4431)

Bien à vous, Tom.

-----

[antek]

MPLABX j'espère !
Les programmes se trouvent dans la doc relative à Explorer8.

Si tu ne fais pas l'effort de lire les doc ça va être difficile . . .

[paulfjujo]

bonjour,


En effet d'apres le schema de ta carte explorer8
le LCD 2x16 chars traditionnel est piloté via le circuit MCP2317 interface SPI / parrallele
il te suffit de potasser un peu la doc de ce circuit MCP , et d'envoyer les memes commandes d'init du LCD
mais via la liaison SPI.

je ne connais que la version MCP23017 en I2C ..(au lieu de SPI)

[invite6374ce44]

Bonjour à vous deux, effectivement je suis bien sous MPLAB X (Version 4.15).

Et oui j'ai bel et bien épluché la doc.. mais je n'arrive pas à saisir comment l'on pilote ce fameux SPI avec les commandes.. et pour ce qui est des programmes, il y en a uniquement des pour les PIC 16F en général, rien pour un 18F ... :/

Puis, comme je l'ai dis précédemment, je suis un bon gros débutant .. ^^'

Par exemple, la pour faire l'Init sans SPI, je procède de cette manière (codes trouvé a droite à gauche en fouillant un peu) :

LCD lcd = { &PORTC, 2, 3, 4, 5, 6, 7 }; // PORT, RS, EN, D4, D5, D6, D7 | Attribution des pins LCD
    LCD_Init(lcd);

Donc ca je l'appelle dans mon main.c

Et la fonction LCD_Init() est déclarée comme ceci :

bool LCD_Init ( LCD display ) {

    lcd = display;

    /*
     * TODO:
     * The function should clear only the appropriate bits, not the whole PORT
     *
     * TODO:
     * "#if defined" needs to support more microcontrollers that have PORTD and PORTE
     */
    if ( lcd.PORT == &PORTA ) {
        TRISA = 0x00;
    }
    else if ( lcd.PORT == &PORTB ) {
        TRISB = 0x00;
    }
    else if ( lcd.PORT == &PORTC ) {
        TRISC = 0x00;
    }
    #if defined(_16F877) || defined(_16F877A)
    else if ( lcd.PORT == &PORTD ) {
        TRISD = 0x00;
    }
    else if ( lcd.PORT == &PORTE ) {
        TRISE = 0x00;
    }
    #endif
    else {
        return false;
    }

    // Give some time to the LCD to start function properly
    __delay_ms(20);

    // Send reset signal to the LCD
    LCD_Write(0x03);
    __delay_ms(5);
    LCD_Write(0x03);
    __delay_ms(16);
    LCD_Write(0x03);

    // Specify the data lenght to 4 bits
    LCD_Write(0x02);

    // Set interface data length to 8 bits, number of display lines to 2 and font to 5x8 dots
    LCD_Cmd(0x28);

    // Set cursor to move from left to right
    LCD_Cmd(0x06);

    LCD_Display(true, false, false); // Turn on display and set cursor off

    LCD_Clear();
    
    return true;
}

Je dois donc adapter les commandes de cet Init la si j'ai bien compris ??

Merci pour votre retour rapide, et pour vos réponses !

[A voir en vidéo sur Futura]

[invited14ca340]

Bonjour,
Oui il faut "simuler" le PORT C avec le MCP23S17. C'est à dire qu'il faudra adapter les fonction LCD_xxxx non plus en écrivant sur le port C mais en envoyant sur le MCP23S17. Si les broches du LCD sont branchées dans le même ordre sur le port du MCP23S17 alors les données pourront être envoyées telles quelle, sinon il faudra faire un peu de manipulation avec des masques et des décalages

Concernant les commandes de configuration à envoyer au MCP23S17 (configuration du port en sortie, écriture sur le port) c'est des valeurs de registre propre au MCP23S17 donc peu importe pour quel PIC a été fait le programme, la seule chose qui dépend du PIC c'est la configuration du port SPI (selon les familles de PIC les registres sont différents, plus ou moins nombreux, etc)

[invite6374ce44]

Bonjour !!
Suite à ta réponse, je suis en train de bricoler un peu avec ce que je trouve et avec ce que tu m'as dis.
Je verrais bien si j'arrive a produire quelque chose !

Dernière chose, j'ai essayer de pomper un programme pré-fait pour 16F et de prendre juste ce qu'il m'intéresse pour le LCD et le SPI.

Lorsque je compile pour voir si tout est OK dans le .h : C'est bon

Mais lorsque que j'appele une fonction dans mon .c comme "LCD_Clear()", j'obtiens ce message d'erreur :

:0: error: (499) undefined symbol:
	_SPI_Exchange8bit(dist/default/production\SPILCD.X.production.obj) 
(908) exit status = 1

[invited14ca340]

Sans le code complet difficile de dire quoi que ce soit, mais à mon avis il y a une déclaration qui n'est pas faite correctement par rapport aux fonctions du SPI.

[invite6374ce44]

Je vais mettre le code complet, j'ai supprimé pas mal de choses qui me semblait inutile pour ce que je veux faire, mais j'ai laissé des lignes de codes dont je n'étais pas sûr de l'utilité, j'espère que tu arriveras à t'y retrouver .. :/

Code du .h:

#ifndef _bordel_H
#define _bordel_H

/**
  Section: Included Files
*/

#include <xc.h>
#include <stdint.h>
#include <stdbool.h>

#define _XTAL_FREQ  8000000

/**
 * @Param
    none
 * @Returns
    none
 * @Description
    Initializes the device to the default states configured in the
 *                  MCC GUI
 * @Example
    SYSTEM_Initialize(void);
 */
void SYSTEM_Initialize(void);


#define INPUT   1
#define OUTPUT  0

#define HIGH    1
#define LOW     0

#define ANALOG      1
#define DIGITAL     0

#define PULL_UP_ENABLED      1
#define PULL_UP_DISABLED     0

// get/set LCD_CHIP_SELECT aliases
#define LCD_CHIP_SELECT_TRIS               TRISAbits.TRISA2
#define LCD_CHIP_SELECT_LAT                LATAbits.LATA2
#define LCD_CHIP_SELECT_PORT               PORTAbits.RA2
#define LCD_CHIP_SELECT_WPU                WPUAbits.WPUA2
#define LCD_CHIP_SELECT_OD                ODCONAbits.ODA2
#define LCD_CHIP_SELECT_ANS                ANSELAbits.ANSA2
#define LCD_CHIP_SELECT_SetHigh()            do { LATAbits.LATA2 = 1; } while(0)
#define LCD_CHIP_SELECT_SetLow()             do { LATAbits.LATA2 = 0; } while(0)
#define LCD_CHIP_SELECT_Toggle()             do { LATAbits.LATA2 = ~LATAbits.LATA2; } while(0)
#define LCD_CHIP_SELECT_GetValue()           PORTAbits.RA2
#define LCD_CHIP_SELECT_SetDigitalInput()    do { TRISAbits.TRISA2 = 1; } while(0)
#define LCD_CHIP_SELECT_SetDigitalOutput()   do { TRISAbits.TRISA2 = 0; } while(0)
#define LCD_CHIP_SELECT_SetPullup()      do { WPUAbits.WPUA2 = 1; } while(0)
#define LCD_CHIP_SELECT_ResetPullup()    do { WPUAbits.WPUA2 = 0; } while(0)
#define LCD_CHIP_SELECT_SetPushPull()    do { ODCONAbits.ODA2 = 0; } while(0)
#define LCD_CHIP_SELECT_SetOpenDrain()   do { ODCONAbits.ODA2 = 1; } while(0)
#define LCD_CHIP_SELECT_SetAnalogMode()  do { ANSELAbits.ANSA2 = 1; } while(0)
#define LCD_CHIP_SELECT_SetDigitalMode() do { ANSELAbits.ANSA2 = 0; } while(0)

// get/set SCK aliases
#define SCK_TRIS               TRISCbits.TRISC3
#define SCK_LAT                LATCbits.LATC3
#define SCK_PORT               PORTCbits.RC3
#define SCK_WPU                WPUCbits.WPUC3
#define SCK_OD                ODCONCbits.ODC3
#define SCK_ANS                ANSELCbits.ANSC3
#define SCK_SetHigh()            do { LATCbits.LATC3 = 1; } while(0)
#define SCK_SetLow()             do { LATCbits.LATC3 = 0; } while(0)
#define SCK_Toggle()             do { LATCbits.LATC3 = ~LATCbits.LATC3; } while(0)
#define SCK_GetValue()           PORTCbits.RC3
#define SCK_SetDigitalInput()    do { TRISCbits.TRISC3 = 1; } while(0)
#define SCK_SetDigitalOutput()   do { TRISCbits.TRISC3 = 0; } while(0)
#define SCK_SetPullup()      do { WPUCbits.WPUC3 = 1; } while(0)
#define SCK_ResetPullup()    do { WPUCbits.WPUC3 = 0; } while(0)
#define SCK_SetPushPull()    do { ODCONCbits.ODC3 = 0; } while(0)
#define SCK_SetOpenDrain()   do { ODCONCbits.ODC3 = 1; } while(0)
#define SCK_SetAnalogMode()  do { ANSELCbits.ANSC3 = 1; } while(0)
#define SCK_SetDigitalMode() do { ANSELCbits.ANSC3 = 0; } while(0)

// get/set SDI aliases
#define SDI_TRIS               TRISCbits.TRISC4
#define SDI_LAT                LATCbits.LATC4
#define SDI_PORT               PORTCbits.RC4
#define SDI_WPU                WPUCbits.WPUC4
#define SDI_OD                ODCONCbits.ODC4
#define SDI_ANS                ANSELCbits.ANSC4
#define SDI_SetHigh()            do { LATCbits.LATC4 = 1; } while(0)
#define SDI_SetLow()             do { LATCbits.LATC4 = 0; } while(0)
#define SDI_Toggle()             do { LATCbits.LATC4 = ~LATCbits.LATC4; } while(0)
#define SDI_GetValue()           PORTCbits.RC4
#define SDI_SetDigitalInput()    do { TRISCbits.TRISC4 = 1; } while(0)
#define SDI_SetDigitalOutput()   do { TRISCbits.TRISC4 = 0; } while(0)
#define SDI_SetPullup()      do { WPUCbits.WPUC4 = 1; } while(0)
#define SDI_ResetPullup()    do { WPUCbits.WPUC4 = 0; } while(0)
#define SDI_SetPushPull()    do { ODCONCbits.ODC4 = 0; } while(0)
#define SDI_SetOpenDrain()   do { ODCONCbits.ODC4 = 1; } while(0)
#define SDI_SetAnalogMode()  do { ANSELCbits.ANSC4 = 1; } while(0)
#define SDI_SetDigitalMode() do { ANSELCbits.ANSC4 = 0; } while(0)

// get/set SDO aliases
#define SDO_TRIS               TRISCbits.TRISC5
#define SDO_LAT                LATCbits.LATC5
#define SDO_PORT               PORTCbits.RC5
#define SDO_WPU                WPUCbits.WPUC5
#define SDO_OD                ODCONCbits.ODC5
#define SDO_ANS                ANSELCbits.ANSC5
#define SDO_SetHigh()            do { LATCbits.LATC5 = 1; } while(0)
#define SDO_SetLow()             do { LATCbits.LATC5 = 0; } while(0)
#define SDO_Toggle()             do { LATCbits.LATC5 = ~LATCbits.LATC5; } while(0)
#define SDO_GetValue()           PORTCbits.RC5
#define SDO_SetDigitalInput()    do { TRISCbits.TRISC5 = 1; } while(0)
#define SDO_SetDigitalOutput()   do { TRISCbits.TRISC5 = 0; } while(0)
#define SDO_SetPullup()      do { WPUCbits.WPUC5 = 1; } while(0)
#define SDO_ResetPullup()    do { WPUCbits.WPUC5 = 0; } while(0)
#define SDO_SetPushPull()    do { ODCONCbits.ODC5 = 0; } while(0)
#define SDO_SetOpenDrain()   do { ODCONCbits.ODC5 = 1; } while(0)
#define SDO_SetAnalogMode()  do { ANSELCbits.ANSC5 = 1; } while(0)
#define SDO_SetDigitalMode() do { ANSELCbits.ANSC5 = 0; } while(0)


/**
  Section: Macro Declarations
*/

#define DUMMY_DATA 0x0

/**
  Section: SPI Module APIs
*/

/**
  @Summary
    Initializes the SPI

  @Description
    This routine initializes the SPI.
    This routine must be called before any other MSSP routine is called.
    This routine should only be called once during system initialization.

  @Preconditions
    None

  @Param
    None

  @Returns
    None

  @Comment
    

  @Example
    <code>
    uint8_t     myWriteBuffer[MY_BUFFER_SIZE];
    uint8_t     myReadBuffer[MY_BUFFER_SIZE];
    uint8_t     writeData;
    uint8_t     readData;
    uint8_t     total;

    SPI_Initialize();

    total = 0;
    do
    {
        total = SPI_Exchange8bitBuffer(&myWriteBuffer[total], MY_BUFFER_SIZE - total, &myWriteBuffer[total]);

        // Do something else...

    } while(total < MY_BUFFER_SIZE);

    readData = SPI_Exchange8bit(writeData);
    </code>
 */
void SPI_Initialize(void);

/**
  @Summary
    Exchanges a data byte over SPI

  @Description
    This routine exchanges a data byte over SPI bus.
    This is a blocking routine.

  @Preconditions
    The SPI_Initialize() routine should be called
    prior to use this routine.

  @Param
    data - data byte to be transmitted over SPI bus

  @Returns
    The received byte over SPI bus

  @Example
    <code>
    uint8_t     writeData;
    uint8_t     readData;
    uint8_t     readDummy;

    SPI_Initialize();

    // for transmission over SPI bus
    readDummy = SPI_Exchange8bit(writeData);

    // for reception over SPI bus
    readData = SPI_Exchange8bit(DUMMY_DATA);
    </code>
 */
uint8_t SPI_Exchange8bit(uint8_t data);

 /**
  @Summary
    Exchanges buffer of data over SPI

  @Description
    This routine exchanges buffer of data (of size one byte) over SPI bus.
    This is a blocking routine.

  @Preconditions
    The SPI_Initialize() routine should be called
    prior to use this routine.

  @Param
    dataIn  - Buffer of data to be transmitted over SPI.
    bufLen  - Number of bytes to be exchanged.
    dataOut - Buffer of data to be received over SPI.

  @Returns
    Number of bytes exchanged over SPI.

  @Example
    <code>
    uint8_t     myWriteBuffer[MY_BUFFER_SIZE];
    uint8_t     myReadBuffer[MY_BUFFER_SIZE];
    uint8_t     total;

    SPI_Initialize();

    total = 0;
    do
    {
        total = SPI_Exchange8bitBuffer(&myWriteBuffer[total], MY_BUFFER_SIZE - total, &myWriteBuffer[total]);

        // Do something else...

    } while(total < MY_BUFFER_SIZE);
    </code>
 */
uint8_t SPI_Exchange8bitBuffer(uint8_t *dataIn, uint8_t bufLen, uint8_t *dataOut);

/**
  @Summary
    Gets the SPI buffer full status

  @Description
    This routine gets the SPI buffer full status

  @Preconditions
    The SPI_Initialize() routine should be called
    prior to use this routine.

  @Param
    None

  @Returns
    true  - if the buffer is full
    false - if the buffer is not full.

  @Example
    Refer to SPI_Initialize() for an example
 */
bool SPI_IsBufferFull(void);

/**
  @Summary
    Gets the status of write collision.

  @Description
    This routine gets the status of write collision.

  @Preconditions
    The SPI_Initialize() routine must have been called prior to use this routine.

  @Param
    None

  @Returns
    true  - if the write collision has occurred.
    false - if the write collision has not occurred.

  @Example
    if(SPI_HasWriteCollisionOccured())
    {
        SPI_ClearWriteCollisionStatus();
    }
*/
bool SPI_HasWriteCollisionOccured(void);

/**
  @Summary
    Clears the status of write collision.

  @Description
    This routine clears the status of write collision.

  @Preconditions
    The SPI_Initialize() routine must have been called prior to use this routine.

  @Param
    None

  @Returns
    None

  @Example
    if(SPI_HasWriteCollisionOccured())
    {
        SPI_ClearWriteCollisionStatus();
    }
*/
void SPI_ClearWriteCollisionStatus(void);

/**
  Section: Macro Declarations
 */
#define IO_EXPD_ADDRESS     0x40  
#define GPIO_A_ADDRESS      0x12
#define GPIO_B_ADDRESS      0x13
#define IO_DIR_A_ADDRESS    0x00
#define IO_DIR_B_ADDRESS    0x01

/**
  Section: Explorer 8 LCD Function Prototypes
 */
void LCD_Initialize(void);
void LCD_WriteIOExpander(uint8_t reg, uint8_t data);
void LCD_WriteCommand(uint8_t cmd);
void LCD_WriteByte(uint8_t data);
void LCD_WriteString(const uint8_t *data);
void LCD_GoTo(uint8_t row, uint8_t column);
void LCD_Clear(void);


 
    #define _XTAL_FREQ          8000000
    #define PRESSED             1
    #define NOT_PRESSED         0
    #define RUNNING             1
    #define NOT_RUNNING         0
    #define RIGHT               1
    #define LEFT                0
    #define LEDs                LATB
    #define LEDs_SetLow()       do { LATB = 0; } while(0)
    #define LEDs_ShiftRight()   do { LATB <<= 1; } while(0)
    #define LEDs_ShiftLeft()    do { LATB >>= 1; } while(0)

    #define INTERRUPT_TMR0InterruptEnable()         do { TMR0IE = 1; } while(0)
    #define INTERRUPT_InterruptOnChangeEnable()     do { INTCONbits.IOCIE = 1; } while(0)
    #define INTERRUPT_IOCPositiveEnable()           do { IOCBP0 = 1; } while(0)
    #define INTERRUPT_TMR0InterruptDisable()        do { TMR0IE = 0; } while(0)
    #define INTERRUPT_InterruptOnChangeDisable()    do { INTCONbits.IOCIE = 0; } while(0)
    #define INTERRUPT_IOCPositiveDisable()          do { IOCBP0 = 0; } while(0)


/**
  Section: Variable Definitions
 */
    uint8_t labNumber = 0;
    uint8_t switchEvent = 0;
    uint8_t labState = NOT_RUNNING;
    uint8_t btnState = NOT_PRESSED;    


#endif

Code du LCD.c :

#include "bordel.h"

/**
  Section: Macro Declarations
 */
#define LCD_CLEAR               0x01
#define LCD_VDD_EN              0x20
#define LCD_FUNCTION_SET        0x3C
#define LCD_SET_DISPLAY         0x0C
#define LCD_SET_DDRAM_ADDRESS   0x80
#define LINE1_START_ADDRESS     0x80
#define LINE2_START_ADDRESS     0xC0
#define OUTPUT_DIR              0x00

/**
  Section: Explorer 8 LCD APIs
 */
void LCD_Initialize(void) {
    LCD_WriteIOExpander(IO_DIR_A_ADDRESS, OUTPUT_DIR);
    LCD_WriteIOExpander(IO_DIR_B_ADDRESS, OUTPUT_DIR);
    LCD_WriteIOExpander(GPIO_A_ADDRESS, LCD_VDD_EN);
    __delay_ms(10);
    LCD_WriteCommand(LCD_FUNCTION_SET);
    __delay_ms(10);
    LCD_WriteCommand(LCD_SET_DISPLAY);
    __delay_ms(10);
    LCD_WriteCommand(LCD_CLEAR);
    __delay_ms(10);
    LCD_WriteCommand(LCD_SET_DISPLAY);
    __delay_ms(130);
    LCD_WriteCommand(LCD_SET_DDRAM_ADDRESS);
    __delay_ms(1);
}

void LCD_WriteIOExpander(uint8_t reg, uint8_t data) {
    LCD_CHIP_SELECT_SetLow();
    SPI_Exchange8bit(IO_EXPD_ADDRESS);
    SPI_Exchange8bit(reg);
    SPI_Exchange8bit(data);
    LCD_CHIP_SELECT_SetHigh();
}

void LCD_WriteCommand(uint8_t cmd) {
    LCD_WriteIOExpander(GPIO_A_ADDRESS, 0x60);  //RS LOW -- E HIGH -- LCD Enabled 
    LCD_WriteIOExpander(GPIO_B_ADDRESS, cmd);   //Write the command on PORT B
    LCD_WriteIOExpander(GPIO_A_ADDRESS, 0x20);  //RS LOW -- E LOW -- LCD Enabled
}

void LCD_WriteByte(uint8_t data) {
    LCD_WriteIOExpander(GPIO_A_ADDRESS, 0xE0);  //RS HIGH -- E HIGH -- LCD Enabled --> This is to choose the data register on the LCD
    LCD_WriteIOExpander(GPIO_B_ADDRESS, data);  //Write the byte on PORT B
    LCD_WriteIOExpander(GPIO_A_ADDRESS, 0xA0);  //RS HIGH -- E LOW -- LCD enabled --> This is to latch the data on the LCD
}

void LCD_WriteString(const uint8_t *data) {
    uint8_t i = 0;
    while (data[i]) {
        LCD_WriteByte(data[i++]);
    }
}

void LCD_GoTo(uint8_t row, uint8_t column) {
    if (row < 2) {
        uint8_t pos = (row == 0) ? (LINE1_START_ADDRESS | column) : (LINE2_START_ADDRESS | column);
        LCD_WriteCommand(pos);
    }
}

void LCD_Clear(void) {
    LCD_WriteCommand(LCD_CLEAR);
    LCD_GoTo(0, 0);
}

Et enfin, code du main.c :

/*
 * File:   main.c
 * Author: Tom
 *
 * Created on 25 avril 2018, 11:09
 */


#include <xc.h>
#include"bordel.h"

void main(void) {
        LCD_GoTo(0,0);
    LCD_WriteString("    Test     ");
    return;
}