Merge pull request #26 from Sensirion/update-sps30-driver

Update included embedded-sps-i2c driver to v3.1.1

Author: rnestler

library.properties

@@ -1,5 +1,5 @@
 name=sensirion-sps
-version=0.9.0
+version=1.0.0
 author=Johannes Winkelmann
 maintainer=Johannes Winkelmann <[email protected]>
 sentence=Support for Sensirion's SPS30 particulate matter sensor

sensirion_arch_config.h

@@ -72,10 +72,6 @@
  */
 #include <stdint.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /**
  * Typedef section for types commonly defined in <stdint.h>
  * If your system does not provide stdint headers, please define them
@@ -90,34 +86,25 @@ extern "C" {
  * typedef char int8_t;
  * typedef unsigned char uint8_t; */
 
-/* Types not typically provided by <stdint.h> */
-typedef float float32_t;
+#ifndef __cplusplus
 
 /**
- * Define the endianness of your architecture:
- * 0: little endian, 1: big endian
- * Use the following code to determine if unsure:
- * ```c
- * #include <stdio.h>
- *
- * int is_big_endian(void) {
- *     union {
- *         unsigned int u;
- *         char c[sizeof(unsigned int)];
- *     } e = { 0 };
- *     e.c[0] = 1;
- *
- *     return (e.i != 1);
- * }
- *
- * int main(void) {
- *     printf("Use #define SENSIRION_BIG_ENDIAN %d\n", is_big_endian());
- *
- *     return 0;
- * }
- * ```
+ * If your platform doesn't define the bool type we define it as int. Depending
+ * on your system update the definition below.
  */
-#define SENSIRION_BIG_ENDIAN 0
+#if __STDC_VERSION__ >= 199901L
+#include <stdbool.h>
+#else
+
+#ifndef bool
+#define bool int
+#define true 1
+#define false 0
+#endif /* bool */
+
+#endif /* __STDC_VERSION__ */
+
+#endif /* __cplusplus */
 
 /**
  * The clock period of the i2c bus in microseconds. Increase this, if your GPIO
@@ -128,8 +115,4 @@ typedef float float32_t;
  */
 #define SENSIRION_I2C_CLOCK_PERIOD_USEC 10
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* SENSIRION_ARCH_CONFIG_H */

sensirion_common.cpp

@@ -38,7 +38,26 @@
 #include "sensirion_common.h"
 #include "sensirion_i2c.h"
 
-uint8_t sensirion_common_generate_crc(uint8_t *data, uint16_t count) {
+uint16_t sensirion_bytes_to_uint16_t(const uint8_t* bytes) {
+    return (uint16_t)bytes[0] << 8 | (uint16_t)bytes[1];
+}
+
+uint32_t sensirion_bytes_to_uint32_t(const uint8_t* bytes) {
+    return (uint32_t)bytes[0] << 24 | (uint32_t)bytes[1] << 16 |
+           (uint32_t)bytes[2] << 8 | (uint32_t)bytes[3];
+}
+
+float sensirion_bytes_to_float(const uint8_t* bytes) {
+    union {
+        uint32_t u32_value;
+        float float32;
+    } tmp;
+
+    tmp.u32_value = sensirion_bytes_to_uint32_t(bytes);
+    return tmp.float32;
+}
+
+uint8_t sensirion_common_generate_crc(const uint8_t* data, uint16_t count) {
     uint16_t current_byte;
     uint8_t crc = CRC8_INIT;
     uint8_t crc_bit;
@@ -56,15 +75,20 @@ uint8_t sensirion_common_generate_crc(uint8_t *data, uint16_t count) {
     return crc;
 }
 
-int8_t sensirion_common_check_crc(uint8_t *data, uint16_t count,
+int8_t sensirion_common_check_crc(const uint8_t* data, uint16_t count,
                                   uint8_t checksum) {
     if (sensirion_common_generate_crc(data, count) != checksum)
         return STATUS_FAIL;
-    return STATUS_OK;
+    return NO_ERROR;
 }
 
-uint16_t sensirion_fill_cmd_send_buf(uint8_t *buf, uint16_t cmd,
-                                     const uint16_t *args, uint8_t num_args) {
+int16_t sensirion_i2c_general_call_reset(void) {
+    const uint8_t data = 0x06;
+    return sensirion_i2c_write(0, &data, (uint16_t)sizeof(data));
+}
+
+uint16_t sensirion_fill_cmd_send_buf(uint8_t* buf, uint16_t cmd,
+                                     const uint16_t* args, uint8_t num_args) {
     uint8_t crc;
     uint8_t i;
     uint16_t idx = 0;
@@ -76,54 +100,57 @@ uint16_t sensirion_fill_cmd_send_buf(uint8_t *buf, uint16_t cmd,
         buf[idx++] = (uint8_t)((args[i] & 0xFF00) >> 8);
         buf[idx++] = (uint8_t)((args[i] & 0x00FF) >> 0);
 
-        crc = sensirion_common_generate_crc((uint8_t *)&buf[idx - 2],
+        crc = sensirion_common_generate_crc((uint8_t*)&buf[idx - 2],
                                             SENSIRION_WORD_SIZE);
         buf[idx++] = crc;
     }
     return idx;
 }
 
-int16_t sensirion_i2c_read_words_as_bytes(uint8_t address, uint8_t *data,
+int16_t sensirion_i2c_read_words_as_bytes(uint8_t address, uint8_t* data,
                                           uint16_t num_words) {
     int16_t ret;
     uint16_t i, j;
     uint16_t size = num_words * (SENSIRION_WORD_SIZE + CRC8_LEN);
     uint16_t word_buf[SENSIRION_MAX_BUFFER_WORDS];
-    uint8_t *const buf8 = (uint8_t *)word_buf;
+    uint8_t* const buf8 = (uint8_t*)word_buf;
 
     ret = sensirion_i2c_read(address, buf8, size);
-    if (ret != STATUS_OK)
+    if (ret != NO_ERROR)
         return ret;
 
     /* check the CRC for each word */
     for (i = 0, j = 0; i < size; i += SENSIRION_WORD_SIZE + CRC8_LEN) {
 
         ret = sensirion_common_check_crc(&buf8[i], SENSIRION_WORD_SIZE,
                                          buf8[i + SENSIRION_WORD_SIZE]);
-        if (ret != STATUS_OK)
+        if (ret != NO_ERROR)
             return ret;
 
         data[j++] = buf8[i];
         data[j++] = buf8[i + 1];
     }
 
-    return STATUS_OK;
+    return NO_ERROR;
 }
 
-int16_t sensirion_i2c_read_words(uint8_t address, uint16_t *data_words,
+int16_t sensirion_i2c_read_words(uint8_t address, uint16_t* data_words,
                                  uint16_t num_words) {
     int16_t ret;
     uint8_t i;
+    const uint8_t* word_bytes;
 
-    ret = sensirion_i2c_read_words_as_bytes(address, (uint8_t *)data_words,
+    ret = sensirion_i2c_read_words_as_bytes(address, (uint8_t*)data_words,
                                             num_words);
-    if (ret != STATUS_OK)
+    if (ret != NO_ERROR)
         return ret;
 
-    for (i = 0; i < num_words; ++i)
-        data_words[i] = be16_to_cpu(data_words[i]);
+    for (i = 0; i < num_words; ++i) {
+        word_bytes = (uint8_t*)&data_words[i];
+        data_words[i] = ((uint16_t)word_bytes[0] << 8) | word_bytes[1];
+    }
 
-    return STATUS_OK;
+    return NO_ERROR;
 }
 
 int16_t sensirion_i2c_write_cmd(uint8_t address, uint16_t command) {
@@ -134,7 +161,7 @@ int16_t sensirion_i2c_write_cmd(uint8_t address, uint16_t command) {
 }
 
 int16_t sensirion_i2c_write_cmd_with_args(uint8_t address, uint16_t command,
-                                          const uint16_t *data_words,
+                                          const uint16_t* data_words,
                                           uint16_t num_words) {
     uint8_t buf[SENSIRION_MAX_BUFFER_WORDS];
     uint16_t buf_size;
@@ -144,14 +171,14 @@ int16_t sensirion_i2c_write_cmd_with_args(uint8_t address, uint16_t command,
 }
 
 int16_t sensirion_i2c_delayed_read_cmd(uint8_t address, uint16_t cmd,
-                                       uint32_t delay_us, uint16_t *data_words,
+                                       uint32_t delay_us, uint16_t* data_words,
                                        uint16_t num_words) {
     int16_t ret;
     uint8_t buf[SENSIRION_COMMAND_SIZE];
 
     sensirion_fill_cmd_send_buf(buf, cmd, NULL, 0);
     ret = sensirion_i2c_write(address, buf, SENSIRION_COMMAND_SIZE);
-    if (ret != STATUS_OK)
+    if (ret != NO_ERROR)
         return ret;
 
     if (delay_us)
@@ -161,7 +188,7 @@ int16_t sensirion_i2c_delayed_read_cmd(uint8_t address, uint16_t cmd,
 }
 
 int16_t sensirion_i2c_read_cmd(uint8_t address, uint16_t cmd,
-                               uint16_t *data_words, uint16_t num_words) {
+                               uint16_t* data_words, uint16_t num_words) {
     return sensirion_i2c_delayed_read_cmd(address, cmd, 0, data_words,
                                           num_words);
 }