Discussion :

[LEROYLudovic]

Bonjour,

mon objectif est de faire fonctionner un afficheur (NHD-0420CW-Ax3) en I2C sur mon STM32. J'ai pour cela récupéré du code que j'essaye de faire fonctionner mais il y a une chose que je n'arrive pas à comprendre.

Dans mon fichier .h je déclare :

- le nombre de ligne, de colonne, l'adresse esclave, le string sur mon afficheur, les adresses DDRAM, le mode, mais SURTOUT les paquets qui seront transmis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
/** @brief Number of display rows */
const   uint8_t     ROW_N = 4;
 
/** @brief Number of display columns */
const   uint8_t     COLUMN_N = 20;
 
/** @brief pin assigned to the Reset line (optional, can be always high) */
const   uint8_t     RES = 16;
 
/** @brief Display I2C Slave address, in 7-bit form: 0x3C if SA0=LOW, 0x3D if SA0=HIGH */
const   uint8_t     SLAVE2W = 0x3C;
 
/** @brief Strings to be displayed */
const   uint8_t     TEXT[4][21] =             {"1-Newhaven Display--",
                                               "2-------Test--------",
                                               "3-16/20-Characters--",
                                               "4!@#$%^&*()_+{}[]<>?"};
 
/** @brief DDRAM address for each line of the display */
uint8_t new_line[4] = {0x80, 0xA0, 0xC0, 0xE0};
 
/** @brief Display mode: 1/3 lines or 2/4 lines; default 2/4 (0x08) */
uint8_t rows = 0x08;
 
/** @brief Packet to be transmitted (max 20 bytes) */
uint16_t tx_packet[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

j'ai donc un tableau nommé tx_packet, de type uint16_t

Dans stdint.h on a =

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typedef unsigned char uint8_t ;
 
typedef unsigned short uint16_t;
 
typedef unsigned long uint32_t;

J'ai choisi uint16_t pour mon tableau des paquets qui seront sous forme d'octets, et uint8_t pour les caractères sur mon afficheur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
uint16_t tx_packet[]
 
const   uint8_t     TEXT[4][21]

Cela vous semble t'il correct ?

Dans mon fichier .c, j'utilise la fonction command comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
command(0x01);

Et lors de la déclaration de cette fonction je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void command(uint8_t commandByte)
{
   tx_packet[0] = 0x00; // Control Byte; C0_bit=0, D/C_bit=0 -> following Data Byte contains command
   tx_packet[1] = commandByte;
   send_packet(2);  // Transmits the two bytes
}

Voilà ma question, est-il possible de faire cela en C, je veux dire remplir le tableau comme ceci [0] [1] sa OK, mais le send_packet(2) envoie-t-il les deux paquets du dessus à ma fonction send_packet ? C'est ça que j'ai du mal à comprendre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void send_packet(uint8_t byteStored)
{
   uint8_t index = 0;  
 
   I2C_GenerateSTART(I2CM_MODULE, ENABLE);
   I2C_SendData(I2CM_MODULE, SLAVE2W);
}

Je tiens à préciser que j'ai récupéré ça en Arduino, c'est pour ça peut être que le fonctionnement ici ne fonctionne pas en C pur !

J'espère avoir était compréhensible, merci beaucoup pour votre aide !

[dalfab]

Cela vous semble t'il correct ?

Non, dans un fichier d'entête on ne doit pas mettre des définitions de variables; seulement des déclarations.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/** @brief Number of display rows */
extern const   uint8_t     ROW_N;
 
/** @brief Number of display columns */
extern const   uint8_t     COLUMN_N;
 
/** @brief pin assigned to the Reset line (optional, can be always high) */
extern const   uint8_t     RES;
 
/** @brief Display I2C Slave address, in 7-bit form: 0x3C if SA0=LOW, 0x3D if SA0=HIGH */
extern const   uint8_t     SLAVE2W;
 
/** @brief Strings to be displayed */
extern const   uint8_t     TEXT[4][21];
 
/** @brief DDRAM address for each line of the display */
extern uint8_t new_line[4];
 
/** @brief Display mode: 1/3 lines or 2/4 lines; default 2/4 (0x08) */
extern uint8_t rows;
 
/** @brief Packet to be transmitted (max 20 bytes) */
extern uint16_t tx_packet[20];

Les définitions doivent être mise dans un fichier C.

Voilà ma question, es t’il possible de faire cela en C, je veut dire remplir le tableau comme ceci [0] [1] sa OK, mais le send_packet(2) envoie t'il les deux paquets du dessus à ma fonction send_packet ? C'est ça que j'ai du mal à comprendre.

En effet, rien ne relie apparemment tx_packet à la fonction send_packet, il faudrait regarder si la fonction I2C_SendData n'a pas un accès direct au tableau tx_packet, il n'y a rien de "magique".

[LEROYLudovic]

Voilà j'ai modifié les définitions (maintenant dans le .c) et les déclarations de variables(dans le .h). Merci beaucoup !

Il n y a rien qui relie send_packet et tx_packet donc la a proprement parler ça ne fonctionne pas j'en suis bien conscient mais je veut dire admettons que j'ai une fonction du genre recupere_packet (uint8_t number) et number étant le nombre de paquet que je souhaite récupérer, ce serait possible d'utiliser send_packet(2), cette syntaxe d'utilisation de fonction parait cohérente en C ?

J'aimerai tant réussir à faire cette fonction me permettant de récupérer mes paquets et démarrer la transmission I2C afin de faire marcher mon afficheur mais je ne sais pas encore faire !

Merci beaucoup ! A bientôt, je l'espère.

[dalfab]

En faisant send_packet(2), la seule chose que l'on transmet à la fonction c'est le nombre 2. Si on veut transmettre aussi le tableau, il faudrait faire send_packet( tx_packet , 2 ); et la fonction devrait être définie comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void send_packet( const uint16_t tx_pack[] , uint8_t byteStored ) { .........

[LEROYLudovic]

Ok oui d'accord je vois mieux merci beaucoup, on est bien d'accord que dans le paramètre de la fonction tu l'as mit en const mais c'est une petite erreur d’inattention :p car la valeur sera changée au cours du temps donc elle ne doit pas être constante c'est bien ça ?

Et également dans le send_packet(tx_packet, 2); tx_packet est inséré sans tableau ? Ce n'est pas plutôt send_packet(tx_packet[], 2); ?

Merci
Cordialement

[dalfab]

Ok oui d'accord je vois mieux merci beaucoup, on est bien d'accord que dans le paramètre de la fonction tu l'as mit en const mais c'est une petite erreur d’inattention :p car la valeur sera changée au cours du temps donc elle ne doit pas être constante c'est bien ça ?

le const ici dit que le tableau ne sera pas modifié par la fonction, le tableau peut être modifié ailleurs et être lui-même non constant.

Et également dans le send_packet(tx_packet, 2); tx_packet est inséré sans tableau ? Ce n'est pas plutôt send_packet(tx_packet[], 2); ?

Non, il faut indiquer le nom du tableau sans les []. Dans la déclaration de la fonction, on doit par contre indiquer que ce qui est reçu permet d'accéder à un tableau et il faut [].

[LEROYLudovic]

Ok je vois merci beaucoup !

J'ai fait ceci pour que ce soit plus propre
.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
/** @brief Packet to be transmitted (max 20 bytes) */
#define MAXPACKET       20
 
/** @brief Packet to be transmitted (max 20 bytes) */
extern 		  uint16_t 	   tx_packet[MAXPACKET];

.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
/** @brief Packet to be transmitted (max 20 bytes) */
uint16_t tx_packet[MAXPACKET]={0};

Lorsque j'appelle ma fonction send_packet là on est bon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   send_packet(tx_packet, 2);	// Transmits the two bytes

Du coup dans la fonction send_packet on change le nom du tableau tx_packet pour éviter de mélanger

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void send_packet(const uint16_t tx_pack[], uint8_t byteStored)

mais du coup quand je fais ça dans la fonction send_packet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	i2cmWrite(SLAVE2W, byteStored, tx_packet[index]);

ici il faut que j'utilise tx_pack[] ? tx_pack[MAXPACKET] ? tx_pack[index] ? tx_packet[index] ? tx_packet[MAXPACKET] ? ou tx_packet[] ???

Si j'ai bien compris c'est comme ça que sa fonctionne ?



Merci, désoler pour les horribles fautes qui se glisse xD

[dalfab]

ici il faut que j'utilise tx_pack[] ? tx_pack[MAXPACKET] ? tx_pack[index] ? tx_packet[index] ? tx_packet[MAXPACKET] ? ou tx_packet[] ???

Je ne connais pas la fonction i2cmWrite(), je suppose qu'elle s'attend à recevoir où sont les données à transmettre, donc il faut passer tx_pack sans les [].
En C, quand on passe un paramètre à une fonction, celle-ci reçoit une copie du paramètre. Il y a une exception : un tableau n'est jamais copié car le nom du tableau représente un pointeur sur le premier élément du tableau. La fonction reçoit donc un pointeur. Et le comportement d'un pointeur est totalement identique à celui d'un tableau, donc on pourrait croire que c'est un tableau à l'arrivée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
tab[i]  <===>  *(tab+i)
ptr+i   <===>  &ptr[i]

[LEROYLudovic]

Ah oui d'accord c'est maintenant beaucoup plus claire;

Voici ma fonction i2cmWrite, tx_pack correspond donc a un tableau d'octet contenant les données a envoyer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/**
 * @brief               Write data on the I2C bus
 *
 * @param[in]   address     The slave address in the 7 least significants bits
 * @param[in]   count       The number of bytes to write
 * @param[in]   bufI2C      An byte array containing the data to send
 */
uint8_t i2cmWrite(uint8_t address, uint16_t count, uint8_t * bufI2C)
{
    uint32_t temp;
    uint32_t timeout;
 
    I2C_GenerateSTART(I2CM_MODULE, ENABLE); // Send START condition
    timeout = I2CM_EVENT_TIMEOUT;			// Reset timeout
    // Wait until SB flag is set: EV5
    while ((I2CM_MODULE->SR1&I2C_SR1_SB) != I2C_SR1_SB)
    {
        if (timeout-- == 0)
        {
#ifdef I2C_DEBUG
            debugSendLine("W - Start timeout");
#endif
            i2cm_fixFailure();
            return FALSE;
        }
    }
 
    I2C_Send7bitAddress(I2CM_MODULE, address, I2C_Direction_Transmitter); // Send slave address
    timeout = I2CM_EVENT_TIMEOUT; 			// Reset timeout
    // Wait until ADDR is set: EV6
    while ((I2CM_MODULE->SR1&I2C_SR1_ADDR) != I2C_SR1_ADDR)
    {
        if (timeout-- == 0)
        {
#ifdef I2C_DEBUG
            debugSendLine("W - ADDR timeout");
#endif
            i2cm_fixFailure();
            return FALSE;
        }
    }
 
    temp = I2CM_MODULE->SR2; 				// Clear ADDR flag by reading SR2 register
    I2C_SendData(I2CM_MODULE, *bufI2C);		// Write the first data in DR register (EV8_1)
    bufI2C++;								// Increment the data
    count--;								// Decrement the number of bytes to be written
 
    while (count--)							// While there is data to be written
    {
        /*
         * Poll on BTF to receive data because in polling mode we can not guarantee the
         * EV8 software sequence is managed before the current byte transfer completes
         */
        i2cm_waitBtfSet();
 
        I2C_SendData(I2CM_MODULE, *bufI2C);	// Send the current byte
        bufI2C++;							// Point to the next byte to be written
    }
 
    i2cm_waitBtfSet();// EV8_2: Wait until BTF is set before programming the STOP
    I2C_GenerateSTOP(I2CM_MODULE, ENABLE);	// Send STOP condition
 
    // Make sure that the STOP bit is cleared by Hardware
    while ((I2CM_MODULE->CR1&I2C_CR1_STOP) == I2C_CR1_STOP)
    	;
 
    temp++; 								// For avoid compiler warning
    return TRUE;
}

Je l'écrit donc comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

i2cmWrite(SLAVE2W, byteStored, tx_pack);

Récap :
tx_pack est utilisé après avoir était défini comme ceci : tx_pack[] en paramètre de fonction qui lui même pointe sur la première valeur du tableau tx_packet qui à était défini comme suit : uint16_t tx_packet[MAXPACKET]={0};

J'ai cet avertissement là :




Merci énormément

[dalfab]

Un avertissement, et il y a pourtant au moins 3 erreurs.
* On ne peut pas considérer un tableau de uint16_t comme un tableau de uint8_t. Pourquoi ne pas avoir défini uint8_t tx_packet[MAXPACKET]?
* La fonction i2cmWrite() attend un pointeur sur une zone uint8_t qu'elle prétend vouloir modifier (car il n'y a pas le mot const).
* L'avertissement semble indiquer que tx_pack est un entier alors que la définition du paramètre était censée être const uint16_t tx_pack[] ou l'équivalent const uint16_t *tx_pack.

[LEROYLudovic]

Merci encore pour ton aide dalfab je ne serai comment te remercier assez.