Lire des words à la place de bytes (fonction I2C)

Version imprimable

Bonjour à tous,
je programme en C un microcontroleur. Je souhaite communiqué avec un capteur en I2C. Il y a deja une librairie de faite pour le capteur et et j'ai besoin d'utiliser dans cette librairie:
i2c_readByte(SLAVE_ADDR_L, DEV_ID_REG, &val[0]);
i2c_readWord(SLAVE_ADDR_L, MAN_ID_REG, &readBackVal[0]);
i2c_writeWord(SLAVE_ADDR_L, RCOUNT_CH0_REG, PROXIMITY_REFCOUNT);

J'ai le

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void i2c_writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *value)
{
    uint8_t i=0;
    I2C_MasterSendStart(devAddr, I2C_WRITE_XFER_MODE);
    I2C_MasterWriteByte(regAddr);
    while (i++ < length) {
        I2C_MasterWriteByte(((uint8_t)*value) >> 8);
        I2C_MasterWriteByte((uint8_t)*value++);
    }
    I2C_MasterSendStop();
}
 
void i2c_writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t value)
{
    i2c_writeWords(devAddr, regAddr, 1, &value);
}

et le

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void I2CReadBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *value)
{
    uint8_t i=0;
    I2C_MasterSendStart(devAddr, I2C_WRITE_XFER_MODE);
    I2C_MasterWriteByte(regAddr);
    I2C_MasterSendRestart(devAddr, I2C_READ_XFER_MODE);
    while (i++ < (length-1)) {
        *value++ = I2C_MasterReadByte(I2C_ACK_DATA);
    }
    *value = I2C_MasterReadByte(I2C_NAK_DATA);
    I2C_MasterSendStop();
}
 
void i2c_readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *value)
{
    I2CReadBytes(devAddr, regAddr, 1, value);
}

Mais je bloque pour le i2c_readWord qui doit être finalement la récupération de 2 bytes:
Si j'essaye:

Code:

1
2
3
4
5
6
7
8
9
10
11
void i2c_readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *value)
{
    uint16_t result = 0;
    uint8_t b;
    I2C_MasterSendStart(devAddr, I2C_WRITE_XFER_MODE);
    I2C_MasterWriteByte(regAddr);
    I2C_MasterSendRestart(devAddr, I2C_READ_XFER_MODE);
    b = I2C_MasterReadByte(I2C_ACK_DATA) << 8;
    *value = b + I2C_MasterReadByte(I2C_ACK_DATA);
    I2C_MasterSendStop();
}

en mettant bien un uint16_t *value en parametre , plus tard dans une des fonction j'ai un warning:

Code:

1
2
3
4
5
6
7
8
9
10
11
void Sensor_checkDevice(void)
{
    uint8_t val[1] = {0};
    uint8_t readBackVal[2] = {0};
    uint16_t data = 0;

    i2c_readByte(SLAVE_ADDR_L, DEV_ID_REG, &val[0]);
    i2c_readWord(SLAVE_ADDR_L, MAN_ID_REG, &readBackVal[0]); <---------INCOMPATIBLE POINTER TYPE PASSING Uint8_t to Uint16_t

    data = ((uint16_t) (readBackVal[0] << 8) | readBackVal[1]);
}

Merci pour votre aide, c'est peu être simple mais je bloque

readBackVal devrait être déclaré comme uint16_t et utilisé comme suit:

Code:

1
2
3
4
5
6
7
8
9
10
11
void Sensor_checkDevice(void)
{
    uint8_t val[1] = {0};
    uint16_t readBackVal = 0;
    uint16_t data = 0;
 
    i2c_readByte(SLAVE_ADDR_L, DEV_ID_REG, &val[0]);
    i2c_readWord(SLAVE_ADDR_L, MAN_ID_REG, &readBackVal); <---------INCOMPATIBLE POINTER TYPE PASSING Uint8_t to Uint16_t
 
    data = readBackVal;
}

Il faut aussi corriger readWord:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
void i2c_readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *value)
{
    uint16_t result = 0;
    uint8_t b;
    I2C_MasterSendStart(devAddr, I2C_WRITE_XFER_MODE);
    I2C_MasterWriteByte(regAddr);
    I2C_MasterSendRestart(devAddr, I2C_READ_XFER_MODE);
    b = I2C_MasterReadByte(I2C_ACK_DATA);
    result = b << 8;
    *value = result + I2C_MasterReadByte(I2C_ACK_DATA);
    I2C_MasterSendStop();
}

02/08/2017, 16h46
ternel

Pourquoi ne pas lire directement &data?

Pour des problèmes de boutisme (endianess)?

Merci bien
mais le soucis c'est que toute la librairie est codé comme ca, ce qui veux dire que si je mets uint16_t, il faut que je change toutes les uint8_tde la librairie...
Pas top comme solution
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void checkDevice(void) { uint8_t val[1] = {0}; uint8_t readBackVal[2] = {0}; uint16_t data = 0; i2c_readByte(SLAVE_ADDR_L, DEV_ID_REG, &val[0]); i2c_readWord(SLAVE_ADDR_L, MAN_ID_REG, &readBackVal[0]); data = ((uint16_t) (readBackVal[0] << 8) | readBackVal[1]); }
Finalement, est ce que la meilleur solution ce serait pas de laissé uint8_t *value et d'écrire le MSB dans la premiere case value[0] et le LSB dans la deuxieme case value[1] pour que le reste de la librairie soit correcte
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void i2c_readWord(uint8_t devAddr, uint8_t regAddr, uint8_t *value) { uint16_t result = 0; uint8_t b; I2C_MasterSendStart(devAddr, I2C_WRITE_XFER_MODE); I2C_MasterWriteByte(regAddr); I2C_MasterSendRestart(devAddr, I2C_READ_XFER_MODE); value[0] = I2C_MasterReadByte(I2C_ACK_DATA); value[1] = I2C_MasterReadByte(I2C_ACK_DATA); I2C_MasterSendStop(); }
Ca me parait trop simple :s

Salut Sasuke1234,
On dirait une question très mal posé ;)

Tu ne veux pas plutôt dire simplement : Comment utilise t-on une telle fonction dans un programme en C ?
void i2c_readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *value)

ps : Dans la fonction void i2c_readWord le retour d'une donnée sur 16 bits est déjà implémenté.
Code:

1 2 3 4 5 6 ... ... b = I2C_MasterReadByte(I2C_ACK_DATA) << 8; *value = b + I2C_MasterReadByte(I2C_ACK_DATA); ...
Pourquoi essayes tu de le refaire dans ton programme ?

Code:

data = ((uint16_t) (readBackVal[0] << 8) | readBackVal[1]);

Et si tu fais simplement ça ?
Code:

1 2 3 4 5 6 7 8 9 void Sensor_checkDevice(void) { uint16_t data = 0; uint16_t *pointeur_data = data; i2c_readWord(SLAVE_ADDR_L, MAN_ID_REG, pointeur_data); /* data contient un mot de 16 bits issu du bus I2C */ }

Salut,
désolé je si je suis pas très claire dans mes explications,
dans la librairie C qui est donné avec le capteur, il y a pleins de fonctions:
par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 uint32_t readMeasProxSensor(void) { uint8_t readBackVal[2] = {0}; uint16_t dataMSB = 0; uint16_t dataLSB = 0; //CH0 measurement i2c_readWord(SLAVE_ADDR_L, DATA_MSB_CH0_REG, &readBackVal[0]); //MSB dataMSB = (((uint16_t) (readBackVal[0] << 8)) | readBackVal[1]) & ~(0xF000); //Mask the upper 4 bits i2c_readWord(SLAVE_ADDR_L, DATA_LSB_CH0_REG, &readBackVal[0]); //LSB dataLSB = (((uint16_t) readBackVal[0] << 8)) | readBackVal[1]; //Mask the upper 4 bits return ( (((uint32_t) dataMSB) << 16) | dataLSB); }
ou encore
Code:

1 2 3 4 5 6 7 void clearDRDY(void) { //Clearing the DRDY bit when INTB interrupt occurs by reading STATUS reg uint8_t readBackVal[2] = {0}; i2c_readWord(SLAVE_ADDR_L, STATUS_REG, &readBackVal[0]); }
Le truc c'est que les fonctions i2c vont dépendre de l'environnement de développement, c'est donc a chacun de faire la sienne.

C'est pourquoi j'ai besoin de la fonction i2c_readWord qui marche avec toutes les fct de la librairie, de sorte de pas à avoir modifier plusieurs lignes de code (c'est plus claire dans ma tête déjà)
Donc en faite si je veux que ca marche pour toutes les fonctions, il faut en paramètre (uint8_t devAddr, uint8_t regAddr, uint8_t value)
puis dans ma fonction readWord, je met le premier octet dans la case 0 et le deuxieme octet dans la case 1

Make sense?

03/08/2017, 10h15
Vincent PETIT

Salut,

Citation:

Envoyé par Sasuke1234

désolé je si je suis pas très claire dans mes explications

Non, non, autant pour moi ! C'est moi qui avait mal compris ta demande et je m'en excuse.

- Tu as une bibliothèque bizarrement implémenté, peut être pour la raison que ternel évoque ?
- Et tu ne peux pas réctifier l'implémentation comme Médinoc te l'a montré.

Je ne sais pas comment t'aider.

Désolé,
Bon courage.
03/08/2017, 11h10
dalfab
En effet l'erreur est dans la bibliothèque fournie.
On ne peut pas écrire :
Code:

1 2 3 uint8_t buffer[N*2]; extern void fct( uint16_t* ); fct( buffer ); // Tentative de conversion uint16_t* vers uint8_t*!!
C'est un non sens (erreur en C++, warning en C). Ça ne peut fonctionner que si le processeur utilise des données 16 bits non alignées, c'était fréquent au siècle dernier, c'est rare aujourd'hui.
Il faut reprendre tous les appels à i2c_readWord()! Cette fonction ne peut que recevoir un uint16_t* par définition et donc on ne doit pas lui passer des uint8_t[] qui risquent ne pas être alignés.

Merci beaucoup,
et pour finirn en quoi faire ca ne marcherais pas?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
void i2c_readWord(uint8_t devAddr, uint8_t regAddr, uint8_t *value)
{
    uint16_t result = 0;
    uint8_t b;
    uint8_t readCounter = 0;
 
    I2C_MasterSendStart(devAddr, I2C_WRITE_XFER_MODE);
    I2C_MasterWriteByte(regAddr);
    I2C_MasterSendRestart(devAddr, I2C_READ_XFER_MODE);
    value[readCounter] = I2C_MasterReadByte(I2C_ACK_DATA);
    readCounter++;
    pData[readCounter] = I2C_MasterReadByte(I2C_ACK_DATA);
 
    I2C_MasterSendStop();
}

les cases des case du tableaux ne sont pas forcement à coté dans la mémoire?