Notion d'utilisation d'un tableau

Version imprimable

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:

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:

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:

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:

1 2 command(0x01);
Et lors de la déclaration de cette fonction je fais :
Code:

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:

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 !

Citation:

Envoyé par LEROYLudovic

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:

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.

Citation:

Envoyé par LEROYLudovic

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

21/02/2018, 16h42
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 :calim2: !

Merci beaucoup ! A bientôt, je l'espère.
21/02/2018, 19h35
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:

void send_packet( const uint16_t tx_pack[] , uint8_t byteStored ) { .........
22/02/2018, 09h49
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
22/02/2018, 10h34
dalfab

Citation:

Envoyé par 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 ?

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.

Citation:

Envoyé par LEROYLudovic

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 [].
22/02/2018, 11h51
LEROYLudovic

1 pièce(s) jointe(s)
Ok je vois merci beaucoup !

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

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:

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:

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:

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

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

Code:

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 ?

Pièce jointe 353553

Merci, désoler pour les horribles fautes qui se glisse xD
22/02/2018, 13h06
dalfab

1 pièce(s) jointe(s)
Citation:

Envoyé par LEROYLudovic

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:

1 2 tab[i] <===> *(tab+i) ptr+i <===> &ptr[i]
Pièce jointe 353611

2 pièce(s) jointe(s)

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:

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:

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à :
Pièce jointe 353657

Pièce jointe 353661

Merci énormément

22/02/2018, 15h43
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.
22/02/2018, 16h22
LEROYLudovic

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