Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1180 connectés 

  FORUM HardWare.fr
  Programmation
  C

  [STM32]Implémentation afficheur oled NHD0420CW en I²C

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[STM32]Implémentation afficheur oled NHD0420CW en I²C

n°2311011
arrgon
Posté le 09-02-2018 à 12:46:04  profilanswer
 

Bonjour,
 
Je dois réaliser un travail ou l'objectif est d'effectuer le comptage de place de parking, et dans ce module je dois implémenter un afficheur permettant d'afficher tel ou tel message.
 
Spécification :
Afficheur oled Alphanumérique :
 
Le module dispose d’un afficheur OLED alphanumérique jaune de quatre lignes de vingt caractères (NHD-0420CW-AY3 de Newhaven Display).
 
Cet afficheur est connecté sur le bus I²C du microcontrôleur (voir documentation pour le protocole de pilotage).
 
Je dois donc piloter cette afficheur en I²C, voici la doc :
 
https://www.newhavendisplay.com/spe [...] CW-AY3.pdf
 
 
Sur mon schéma de l'afficheur (on peut voir que toute les sorties qui ont besoin d'être à la masse pour un fonctionnement en I²C sont bien à la masse).
 
 
On peut également remarquer que BS0 BS1 et BS2 sont configuré de tel manière à ce quel'I²C soit activé :
 
J'ai récupérer le code de la doc et j'ai voulue l'implémenter.
 
Bien évidemment j'utilise des variables non reconnues etc.. J'ai donc demander à mon supérieur la possibilité de récuperer les biblothèques de l'afficheur afin d'appeler les fonctions directement et de m'en servir comme je l'entend, mais voilà il m'a répondu : "tu n'en a pas besoin tu le pilote en I²C", je ne comprend donc pas comment je peut faire pour gérer mon afficheur en I²C ?
 
Je gère l'I²C sur mon µC STM32F10x de cette manière :
 
 

Code :
  1. GPIO_InitTypeDef initStruct;
  3.     GPIO_DeInit(GPIOA);
  4.     GPIO_DeInit(GPIOB);
  6.       ...
  8. // I2C SCL / SDA
  9.     initStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  10.     initStruct.GPIO_Mode = GPIO_Mode_Out_PP;


      ...
 

Code :
  1. void gpio_i2cIoStopCondition(void)
  2. {
  3.     // B6 -> SCL / B7 -> SDA
  4.     // Stop condition is SDA rising edge while SCL = 1
  5.     GPIO_WriteBit(GPIOB,GPIO_Pin_7, Bit_RESET);
  6.     fnop();
  7.     GPIO_WriteBit(GPIOB,GPIO_Pin_6, Bit_SET);
  8.     fnop();
  9.     GPIO_WriteBit(GPIOB,GPIO_Pin_7, Bit_SET);
  10.     fnop();
  11. }


 
Pensez vous que je dois utiliser les fonctions des bibliothèques I²C ?
 
Je vous avoue être perdue quant à la façon d'aborder cette tâche :/ !
 
 
Il y a également toute la partie I2C codé par mon collège :
 

Code :
  1. /**********************/
  2. /****** includes ******/
  3. /**********************/
  4. #include "i2cMaster.h"
  6. /*******************/
  7. /***** globals *****/
  8. /*******************/
  10. /** @brief Buffer used to store I2C frames */
  11. uint8_t i2cBuffer[I2CM_BUFFER_SIZE];
  13. /** @brief I2C error flag */
  14. uint8_t i2cIsError;
  16. /*********************************/
  17. /****** Function definition ******/
  18. /*********************************/
  20. /**
  21. * @brief Initialize the I2C master
  22. */
  23. void i2cmInit(void)
  24. {
  25.     I2C_InitTypeDef initStruct;
  27.     I2C_DeInit(I2CM_MODULE);
  28.     I2C_StructInit(&initStruct);
  29.     initStruct.I2C_ClockSpeed = 100000;
  30.     I2C_Init(I2CM_MODULE,&initStruct);
  31.     i2cIsError = FALSE;
  33.     I2C_Cmd(I2CM_MODULE,ENABLE);
  34. }
  36. /**
  37. * @brief       Write data on the I2C bus
  38. *
  39. * @param[in]   address     The slave address in the 7 least significants bits
  40. * @param[in]   count       The number of bytes to write
  41. * @param[in]   bufI2C      An byte array containing the data to send
  42. */
  43. uint8_t i2cmWrite(uint8_t address, uint16_t count, uint8_t * bufI2C)
  44. {
  45.     uint32_t temp;
  46.     uint32_t timeout;
  48.     I2C_GenerateSTART(I2CM_MODULE, ENABLE); // Send START condition
  49.     timeout = I2CM_EVENT_TIMEOUT;           // Reset timeout
  50.     // Wait until SB flag is set: EV5
  51.     while ((I2CM_MODULE->SR1&I2C_SR1_SB) != I2C_SR1_SB)
  52.     {
  53.         if (timeout-- == 0)
  54.         {
  55. #ifdef I2C_DEBUG
  56.             debugSendLine("W - Start timeout" );
  57. #endif
  58.             i2cm_fixFailure();
  59.             return FALSE;
  60.         }
  61.     }
  63.     I2C_Send7bitAddress(I2CM_MODULE, address, I2C_Direction_Transmitter); // Send slave address
  64.     timeout = I2CM_EVENT_TIMEOUT;           // Reset timeout
  65.     // Wait until ADDR is set: EV6
  66.     while ((I2CM_MODULE->SR1&I2C_SR1_ADDR) != I2C_SR1_ADDR)
  67.     {
  68.         if (timeout-- == 0)
  69.         {
  70. #ifdef I2C_DEBUG
  71.             debugSendLine("W - ADDR timeout" );
  72. #endif
  73.             i2cm_fixFailure();
  74.             return FALSE;
  75.         }
  76.     }
  78.     temp = I2CM_MODULE->SR2;                 // Clear ADDR flag by reading SR2 register
  79.     I2C_SendData(I2CM_MODULE, *bufI2C);     // Write the first data in DR register (EV8_1)
  80.     bufI2C++;                               // Increment the data
  81.     count--;                                // Decrement the number of bytes to be written
  83.     while (count--)                         // While there is data to be written
  84.     {
  85.         /*
  86.          * Poll on BTF to receive data because in polling mode we can not guarantee the
  87.          * EV8 software sequence is managed before the current byte transfer completes
  88.          */
  89.         i2cm_waitBtfSet();
  91.         I2C_SendData(I2CM_MODULE, *bufI2C); // Send the current byte
  92.         bufI2C++;                           // Point to the next byte to be written
  93.     }
  95.     i2cm_waitBtfSet();// EV8_2: Wait until BTF is set before programming the STOP
  96.     I2C_GenerateSTOP(I2CM_MODULE, ENABLE);  // Send STOP condition
  98.     // Make sure that the STOP bit is cleared by Hardware
  99.     while ((I2CM_MODULE->CR1&I2C_CR1_STOP) == I2C_CR1_STOP)
  100.         ;
  102.     temp++;                                 // For avoid compiler warning
  103.     return TRUE;
  104. }
  105. /**
  106. * @brief       Read data on the I2C bus
  107. *
  108. * @param[in]   address     The slave address in the 7 least significants bits
  109. * @param[in]   count       The number of bytes to read
  110. * @param[out]  bufI2C      An byte array in which store read data
  111. */
  112. uint8_t i2cmRead(uint8_t address, uint16_t count, uint8_t *bufI2C)
  113. {
  114.     uint32_t temp = 0;
  115.     uint32_t timeout = 0;
  117.     // Enable I2C errors interrupts (used in all modes: Polling, DMA and Interrupts
  118.     I2C_ITConfig(I2CM_MODULE, I2C_IT_ERR,ENABLE);
  120.     if (count == 1)
  121.     {
  122.         I2C_GenerateSTART(I2CM_MODULE, ENABLE);     // Send START condition
  123.         timeout = I2CM_EVENT_TIMEOUT;               // Reset timeout
  124.         // Wait until SB flag is set: EV5
  125.         while ((I2CM_MODULE->SR1&0x0001) != 0x0001)
  126.         {
  127.             if (timeout-- == 0)
  128.             {
  129. #ifdef I2C_DEBUG
  130.                 debugSendLine("R-1 - Start timeout" );
  131. #endif
  132.                 i2cm_fixFailure();
  133.                 return FALSE;
  134.             }
  135.         }
  137.         // Send slave address
  138.         I2C_Send7bitAddress(I2CM_MODULE, address, I2C_Direction_Receiver);
  139.         /*
  140.          * Wait until ADDR is set: EV6_3, then program ACK = 0, clear ADDR
  141.          * and program the STOP just after ADDR is cleared. The EV6_3
  142.          * software sequence must complete before the current byte end of transfer.
  143.          */
  144.         timeout = I2CM_EVENT_TIMEOUT;               // Reset timeout
  145.         // Wait until ADDR is set
  146.         while ((I2CM_MODULE->SR1&0x0002) != 0x0002)
  147.         {
  148.             if (timeout-- == 0)
  149.             {
  150. #ifdef I2C_DEBUG
  151.                 debugSendLine("R-1 - ADDR timeout" );
  152. #endif
  153.                 i2cm_fixFailure();
  154.                 return FALSE;
  155.             }
  156.         }
  158.         I2C_AcknowledgeConfig(I2CM_MODULE, DISABLE); // Clear ACK bit
  160.         /*
  161.          * Disable all active IRQs around ADDR clearing and STOP programming because the EV6_3
  162.          * software sequence must complete before the current byte end of transfer
  163.          */
  164.         __disable_irq();
  165.         temp = I2CM_MODULE->SR2;                     // Clear ADDR flag by reading SR2 register
  166.         I2C_GenerateSTOP(I2CM_MODULE, ENABLE);      // Program the STOP
  167.         __enable_irq();                             // Re-enable IRQs
  169.         i2cm_waitRxneSet(); // Wait until a data is received in DR register (RXNE = 1) EV7
  170.         *bufI2C = I2C_ReceiveData(I2CM_MODULE);     // Read the data
  172.         // Make sure that the STOP bit is cleared by Hardware before CR1 write access
  173.         while ((I2CM_MODULE->CR1&0x200) == 0x200)
  174.             ;
  175.     }
  176.     // ------ For send two bytes
  177.     else if (count == 2)
  178.     {
  179.         I2CM_MODULE->CR1 |= CR1_POS_Set;             // Set POS bit
  181.         I2C_GenerateSTART(I2CM_MODULE, ENABLE);     // Send START condition
  182.         timeout = I2CM_EVENT_TIMEOUT;               // Reset timeout
  183.         // Wait until SB flag is set: EV5
  184.         while ((I2CM_MODULE->SR1&0x0001) != 0x0001)
  185.         {
  186.             if( timeout-- == 0)
  187.             {
  188. #ifdef I2C_DEBUG
  189.                 debugSendLine("R-2 - Start timeout" );
  190. #endif
  191.                 i2cm_fixFailure();
  192.                 return FALSE;
  193.             }
  194.         }
  196.         // Send slave address
  197.         I2C_Send7bitAddress(I2CM_MODULE, address, I2C_Direction_Receiver);
  198.         timeout = I2CM_EVENT_TIMEOUT;            // Reset timeout
  199.         // Wait until ADDR is set: EV6
  200.         while ((I2CM_MODULE->SR1&0x0002) != 0x0002)
  201.         {
  202.             if (timeout-- == 0)
  203.             {
  204. #ifdef I2C_DEBUG
  205.                 debugSendLine("R-2 - ADDR timeout" );
  206. #endif
  207.                 i2cm_fixFailure();
  208.                 return FALSE;
  209.             }
  210.         }
  211.         /*
  212.          * EV6_1: The acknowledge disable should be done just after EV6,
  213.          * that is after ADDR is cleared, so disable all active IRQs around ADDR clearing and
  214.          * ACK clearing
  215.          */
  216.         __disable_irq();
  217.         temp = I2CM_MODULE->SR2;                     // Clear ADDR by reading SR2 register
  218.         I2C_AcknowledgeConfig(I2CM_MODULE,DISABLE); // Clear ACK bit
  219.         __enable_irq();                             //Re-enable IRQs
  221.         i2cm_waitBtfSet();                          // Wait until BTF is set
  223.         // Disable IRQs around STOP programming and data reading because of the limitation ?
  224.         __disable_irq();
  225.         I2C_GenerateSTOP(I2CM_MODULE,ENABLE);       // Program the STOP
  226.         *bufI2C = I2C_ReceiveData(I2CM_MODULE);     // Read first data
  227.         __enable_irq();                             // Re-enable IRQs
  229.         bufI2C++;
  230.         *bufI2C = I2C_ReceiveData(I2CM_MODULE);     // Read second data
  232.         /* Make sure that the STOP bit is cleared by Hardware before CR1 write access */
  233.         while ((I2CM_MODULE->CR1&0x200) == 0x200)
  234.             ;
  235.         I2CM_MODULE->CR1  &= CR1_POS_Reset;          // Clear POS bit
  236.     }
  237.     // ------ For send more than two bytes
  238.     else
  239.     {
  240.         I2C_GenerateSTART(I2CM_MODULE, ENABLE);     // Send START condition
  241.         timeout = I2CM_EVENT_TIMEOUT;               // Reset timeout
  242.         // Wait until SB flag is set: EV5
  243.         while ((I2CM_MODULE->SR1&0x0001) != 0x0001)
  244.         {
  245.             if (timeout-- == 0)
  246.             {
  247. #ifdef I2C_DEBUG
  248.                 debugSendLine("R>2 - Start timeout" );
  249. #endif
  250.                 i2cm_fixFailure();
  251.                 return FALSE;
  252.             }
  253.         }
  255.         // Send slave address
  256.         I2C_Send7bitAddress(I2CM_MODULE,address,I2C_Direction_Receiver);
  257.         timeout = I2CM_EVENT_TIMEOUT;               // Reset timeout
  258.         // Wait until ADDR is set: EV6
  259.         while ((I2CM_MODULE->SR1&0x0002) != 0x0002)
  260.         {
  261.             if (timeout-- == 0)
  262.             {
  263. #ifdef I2C_DEBUG
  264.                 debugSendLine("R>2 - ADDR timeout" );
  265. #endif
  266.                 i2cm_fixFailure();
  267.                 return FALSE;
  268.             }
  269.         }
  271.         temp = I2CM_MODULE->SR2; // Clear ADDR by reading SR2 status register
  272.         while (count)               // While there is data to be read
  273.         {
  274.             if (count != 3)         // Receive bytes from first byte until byte N-3
  275.             {
  276.                 /*
  277.                  * Poll on BTF to receive data because in polling mode we can not guarantee the
  278.                  * EV7 software sequence is managed before the current byte transfer completes
  279.                  */
  280.                 i2cm_waitBtfSet();
  281.                 *bufI2C = I2C_ReceiveData(I2CM_MODULE); // Read data
  282.                 bufI2C++;
  283.                 count--;                                // Decrement the read bytes counter
  284.             }
  285.             /* it remains to read three data: data N-2, data N-1, Data N */
  286.             if (count == 3)
  287.             {
  288.                 // Wait until BTF is set: Data N-2 in DR and data N -1 in shift register
  289.                 i2cm_waitBtfSet();
  290.                 I2C_AcknowledgeConfig(I2CM_MODULE,DISABLE); // Clear ACK bit
  292.                 /*
  293.                  * Disable IRQs around data reading and STOP programming because of the
  294.                  * limitation ?
  295.                  */
  296.                 __disable_irq();
  297.                 *bufI2C = I2C_ReceiveData(I2CM_MODULE); // Read Data N-2
  298.                 bufI2C++;                               // Increment
  299.                 I2C_GenerateSTOP(I2CM_MODULE,ENABLE);   // Program the STOP
  300.                 *bufI2C = I2C_ReceiveData(I2CM_MODULE); // Read Data N-1
  301.                 __enable_irq();                         // Re-enable IRQs
  303.                 bufI2C++;                               // Increment
  304.                 i2cm_waitRxneSet(); // Wait until RXNE is set (DR contains the last data)
  305.                 *bufI2C = I2C_ReceiveData(I2CM_MODULE); // Read DataN
  306.                 count = 0;          // Reset the number of bytes to be read by master
  307.             }
  308.         }
  310.         /* Make sure that the STOP bit is cleared by Hardware before CR1 write access */
  311.         while((I2CM_MODULE->CR1&0x200) == 0x200)
  312.             ;
  313.     }
  315.     I2C_AcknowledgeConfig(I2CM_MODULE, ENABLE); // Enable Acknowledgment to be ready for another reception
  316.     temp++;                                     // For avoid compiler warning
  318.     return TRUE;
  319. }
  321. /**
  322. * @brief           Write and read data on the I2C bus
  323. *
  324. * @param[in]       address         The slave address in the 7 least significants bits
  325. * @param[in]       countWrite      The number of bytes to write
  326. * @param[in]       countRead       The number of bytes to read
  327. * @param[in, out]  bufI2C          An byte array in which store read data
  328. *
  329. * @return 1 if there is a problem during write operation, 0 otherwise
  330. *
  331. * In a first time, this function write the <tt>writeCount</tt> first bytes of bufI2C array.<br>
  332. * Then, in a second time, this function read <tt>readCount</tt> bytes on I2C and store them in bufI2C.
  333. */
  334. uint8_t i2cmWriteAndRead(uint8_t address, uint16_t countWrite, uint16_t countRead, uint8_t *bufI2C)
  335. {
  337.     if (i2cmWrite(address, countWrite, bufI2C))
  338.     {
  339.         if (i2cmRead(address, countRead, bufI2C))
  340.             return TRUE;
  341.     }
  342.     return FALSE;
  343. }
  345. /**
  346. * @brief  This function handles I2C1 Error interrupt request.
  347. */
  348. void I2C1_ER_IRQHandler(void)
  349. {
  350.     __IO uint32_t SR1Register = 0;
  352.     // Read the I2C1 status register
  353.     SR1Register = I2C1->SR1;
  354.     // If AF = 1
  355.     if ((SR1Register & 0x0400) == 0x0400)
  356.     {
  357.         I2C1->SR1 &= 0xFBFF;
  358.         SR1Register = 0;
  359.     }
  360.     // If ARLO = 1
  361.     if((SR1Register & 0x0200) == 0x0200)
  362.     {
  363.         I2C1->SR1 &= 0xFBFF;
  364.         SR1Register = 0;
  365.     }
  366.     // If BERR = 1
  367.     if((SR1Register & 0x0100) == 0x0100)
  368.     {
  369.         I2C1->SR1 &= 0xFEFF;
  370.         SR1Register = 0;
  371.     }
  373.     // If OVR = 1
  374.     if((SR1Register & 0x0800) == 0x0800)
  375.     {
  376.         I2C1->SR1 &= 0xF7FF;
  377.         SR1Register = 0;
  378.     }
  380.     i2cIsError = TRUE;
  381. }
  383. /**
  384. * @brief Wait for the end of the byte transfer (bit BTF of register SR1)
  385. */
  386. void i2cm_waitBtfSet(void)
  387. {
  388.     i2cm_waitSr1BitSet(I2C_SR1_BTF); // Wait until BTF is set
  389. }
  391. /**
  392. * @brief Wait for the reception of a byte (bit RxNE of register SR1)
  393. */
  394. void i2cm_waitRxneSet(void)
  395. {
  396.     i2cm_waitSr1BitSet(I2C_SR1_RXNE); // Wait until RXNE is set
  397. }
  399. /**
  400. * @brief       Wait until the bit <tt>bitToWait</tt> is set in register SR1
  401. *
  402. * @param[in]   bitToWait   The bit to wait
  403. */
  404. void i2cm_waitSr1BitSet(uint8_t bitToWait)
  405. {
  406.     while ((I2C_ReadRegister(I2CM_MODULE,I2C_Register_SR1)&bitToWait) != bitToWait)
  407.         ;
  408.     //softDelay(1);
  409. }
  411. /**
  412. * @brief Fix an I2C failure
  413. */
  414. void i2cm_fixFailure(void)
  415. {
  416.     GPIO_InitTypeDef initStruct;
  418.     I2C_SoftwareResetCmd(I2CM_MODULE, ENABLE);
  419.     initStruct.GPIO_Speed = GPIO_Speed_50MHz;
  420.     initStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  421.     initStruct.GPIO_Mode = GPIO_Mode_Out_PP;
  422.     GPIO_Init(GPIOB, &initStruct);
  423.     GPIO_WriteBit(GPIOB, initStruct.GPIO_Pin, Bit_RESET);
  424.     softDelay(20);
  425.     I2C_SoftwareResetCmd(I2CM_MODULE, DISABLE);
  426.     //initStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  427.     initStruct.GPIO_Mode = GPIO_Mode_AF_OD;
  428.     GPIO_Init(GPIOB, &initStruct);
  429.     softDelay(20);
  430.     i2cmInit();
  431. }


 
 
Merci à vous d'avoir pris le temps, je vous souhaite une excellente journée ! Merci !

mood
Publicité
Posté le 09-02-2018 à 12:46:04  profilanswer
 

n°2311035
rat de com​bat
attention rongeur méchant!
Posté le 09-02-2018 à 21:09:42  profilanswer
 

Mauvaise cat', si un modérateur peut déplacer...
 
Je suis pas sûr d'avoir compris où est ton problème... Vu ton code tu sembles faire du I2C en pure software, c'est possible mais chiant et inutile si ton µC a un module hardware I2C. Dans ce dernier cas il suffit de lire la doc du µC pour savoir comment faire fonctionner ce module et la doc de l'afficheur pour savoir quoi lui envoyer. Après le mieux c'est de faire une petite bibliothèque avec des fonctions genre effacer_lcd(), afficher_texte() ou semblable pour que l'utilisation soit simple et confortable.


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  [STM32]Implémentation afficheur oled NHD0420CW en I²C

 

Sujets relatifs
[Langage C] Problème d'affichage Chat 2 clientsconcatenation de Label C++ builder
[C++] Lambda capture de pointeur[C++] Organisation et conventions d'un projet NMake
C# Word CustomPropertiesC++ builder Firemonkey créer une Image avec Bitmap
[RÉSOLU] Garder colonnes H et I masquées pendant Affichage de G et JDesassembler un programme linux (en C)
[C++] Utilisation fonction simple[C] Problème de compilation entre emcc et OpenSSL (Résolu)
Plus de sujets relatifs à : [STM32]Implémentation afficheur oled NHD0420CW en I²C

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.149 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR