Rework force system

extras/ads111x/ads111x.c

@@ -55,7 +55,7 @@ const float ads111x_gain_values[] = {
 static uint16_t read_reg(uint8_t addr, uint8_t reg)
 {
     uint16_t res = 0;
-    if (i2c_slave_read(addr, &reg, (uint8_t *)&res, 2, false))
+    if (i2c_slave_read(addr, &reg, (uint8_t *)&res, 2))
         debug("Could not read register %d", reg);
     //debug("Read %d: 0x%04x", reg, res);
     return res;
@@ -65,7 +65,7 @@ static void write_reg(uint8_t addr, uint8_t reg, uint16_t val)
 {
     //debug("Write %d: 0x%04x", reg, val);
     uint8_t buf[2] = { val >> 8, val};
-    if (i2c_slave_write(addr, &reg, buf, 2, false))
+    if (i2c_slave_write(addr, &reg, buf, 2))
         debug("Could not write 0x%04x to register %d", val, reg);
 }
 

extras/bmp180/bmp180.c

@@ -44,7 +44,7 @@ static int bmp180_readRegister16(uint8_t reg, int16_t *r)
     uint8_t d[] = { 0, 0 };
     int error ;
 
-    if ((error = i2c_slave_read(BMP180_DEVICE_ADDRESS, &reg, d, 2, false)))
+    if ((error = i2c_slave_read(BMP180_DEVICE_ADDRESS, &reg, d, 2)))
         return error;
 
     *r = ((int16_t)d[0] << 8) | (d[1]);
@@ -55,7 +55,7 @@ static int bmp180_start_Messurement(uint8_t cmd)
 {
     uint8_t reg = BMP180_CONTROL_REG ;
 
-    return i2c_slave_write(BMP180_DEVICE_ADDRESS, &reg, &cmd, 1, false);
+    return i2c_slave_write(BMP180_DEVICE_ADDRESS, &reg, &cmd, 1);
 }
 
 static bool bmp180_get_uncompensated_temperature(int32_t *ut)
@@ -96,7 +96,7 @@ static bool bmp180_get_uncompensated_pressure(uint8_t oss, uint32_t *up)
 
     uint8_t d[] = { 0, 0, 0 };
     uint8_t reg = BMP180_OUT_MSB_REG;
-    if (i2c_slave_read(BMP180_DEVICE_ADDRESS, &reg, d, 3, false))
+    if (i2c_slave_read(BMP180_DEVICE_ADDRESS, &reg, d, 3))
         return false;
 
     uint32_t r = ((uint32_t)d[0] << 16) | ((uint32_t)d[1] << 8) | d[2];
@@ -143,7 +143,7 @@ bool bmp180_is_available()
 {
     uint8_t id;
     uint8_t reg = BMP180_VERSION_REG;
-    if (i2c_slave_read(BMP180_DEVICE_ADDRESS, &reg, &id, 1, false))
+    if (i2c_slave_read(BMP180_DEVICE_ADDRESS, &reg, &id, 1))
         return false;
     return id == BMP180_CHIP_ID;
 }

extras/bmp280/bmp280.c

@@ -69,7 +69,7 @@ void bmp280_init_default_params(bmp280_params_t *params)
 static bool read_register16(uint8_t i2c_addr, uint8_t addr, uint16_t *value)
 {
     uint8_t d[] = {0, 0};
-    if (!i2c_slave_read(i2c_addr, &addr, d, sizeof(d), false)) {
+    if (!i2c_slave_read(i2c_addr, &addr, d, sizeof(d))) {
         *value = d[0] | (d[1] << 8);
         return true;
     }
@@ -78,7 +78,7 @@ static bool read_register16(uint8_t i2c_addr, uint8_t addr, uint16_t *value)
 
 static inline int read_data(uint8_t i2c_addr, uint8_t addr, uint8_t *value, uint8_t len)
 {
-    return i2c_slave_read(i2c_addr, &addr, value, len, false);
+    return i2c_slave_read(i2c_addr, &addr, value, len);
 }
 
 static bool read_calibration_data(bmp280_t *dev)
@@ -146,7 +146,7 @@ static bool read_hum_calibration_data(bmp280_t *dev)
 
 static int write_register8(uint8_t i2c_addr, uint8_t addr, uint8_t value)
 {
-    return i2c_slave_write(i2c_addr, &addr, &value, 1, false);
+    return i2c_slave_write(i2c_addr, &addr, &value, 1);
 }
 
 bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)

extras/ds1307/ds1307.c

@@ -43,7 +43,7 @@ static uint8_t dec2bcd(uint8_t val)
 static uint8_t read_register(uint8_t reg)
 {
     uint8_t val;
-    i2c_slave_read(ADDR, &reg, &val, 1, false);
+    i2c_slave_read(ADDR, &reg, &val, 1);
     return val;
 }
 
@@ -51,7 +51,7 @@ static void update_register(uint8_t reg, uint8_t mask, uint8_t val)
 {
     uint8_t buf = (read_register(reg) & mask) | val;
 
-    i2c_slave_write(ADDR, &reg, &buf, 1, false);
+    i2c_slave_write(ADDR, &reg, &buf, 1);
 }
 
 void ds1307_start(bool start)
@@ -69,7 +69,7 @@ void ds1307_get_time(struct tm *time)
     uint8_t buf[7];
     uint8_t reg = TIME_REG ;
 
-    i2c_slave_read(ADDR, &reg , buf, 7 , false);
+    i2c_slave_read(ADDR, &reg , buf, 7);
 
     time->tm_sec = bcd2dec(buf[0] & SECONDS_MASK);
     time->tm_min = bcd2dec(buf[1]);
@@ -99,7 +99,7 @@ void ds1307_set_time(const struct tm *time)
     buf[6] = dec2bcd(time->tm_mon + 1);
     buf[7] = dec2bcd(time->tm_year - 2000);
 
-    i2c_slave_write(ADDR, &buf[0], &buf[1] , 7, false);
+    i2c_slave_write(ADDR, &buf[0], &buf[1] , 7);
 }
 
 void ds1307_enable_squarewave(bool enable)
@@ -137,7 +137,7 @@ int ds1307_read_ram(uint8_t offset, uint8_t *buf, uint8_t len)
     if (offset + len > RAM_SIZE) return false;
     uint8_t reg = RAM_REG + offset ;
 
-    return i2c_slave_read(ADDR, &reg, buf, len, false);
+    return i2c_slave_read(ADDR, &reg, buf, len);
 }
 
 int ds1307_write_ram(uint8_t offset, uint8_t *buf, uint8_t len)
@@ -145,5 +145,5 @@ int ds1307_write_ram(uint8_t offset, uint8_t *buf, uint8_t len)
     if (offset + len > RAM_SIZE) return false;
     uint8_t reg = RAM_REG + offset ;
 
-    return i2c_slave_write(ADDR, &reg, buf, len, false);
+    return i2c_slave_write(ADDR, &reg, buf, len);
 }

extras/ds3231/ds3231.c

@@ -30,7 +30,7 @@ static inline uint8_t  bcdToDec(uint8_t bcd)
  */
 static inline int ds3231_send(uint8_t reg, uint8_t *data, uint8_t len)
 {
-    return i2c_slave_write(DS3231_ADDR, &reg, data, len, false);
+    return i2c_slave_write(DS3231_ADDR, &reg, data, len);
 }
 
 /* Read a number of bytes from the rtc over i2c
@@ -38,7 +38,7 @@ static inline int ds3231_send(uint8_t reg, uint8_t *data, uint8_t len)
  */
 static inline int ds3231_recv(uint8_t reg, uint8_t *data, uint8_t len)
 {
-    return i2c_slave_read(DS3231_ADDR, &reg, data, len, false);
+    return i2c_slave_read(DS3231_ADDR, &reg, data, len);
 }
 
 int ds3231_setTime(struct tm *time)

extras/hmc5883l/hmc5883l.c

@@ -54,13 +54,13 @@ static hmc5883l_operating_mode_t current_mode;
 
 static inline void write_register(uint8_t reg, uint8_t val)
 {
-    i2c_slave_write(ADDR, &reg, &val, 1, false);
+    i2c_slave_write(ADDR, &reg, &val, 1);
 }
 
 static inline uint8_t read_register(uint8_t reg)
 {
     uint8_t res;
-    i2c_slave_read(ADDR, &reg, &res, 1, false);
+    i2c_slave_read(ADDR, &reg, &res, 1);
     return res;
 }
 
@@ -82,7 +82,7 @@ uint32_t hmc5883l_get_id()
 {
     uint32_t res = 0;
     uint8_t reg = REG_ID_A;
-    i2c_slave_read(ADDR, &reg, (uint8_t *)&res, 3, false);
+    i2c_slave_read(ADDR, &reg, (uint8_t *)&res, 3);
     return res;
 }
 
@@ -165,7 +165,7 @@ bool hmc5883l_get_raw_data(hmc5883l_raw_data_t *data)
     }
     uint8_t buf[6];
     uint8_t reg = REG_DX_H;
-    i2c_slave_read(ADDR, &reg, buf, 6, false);
+    i2c_slave_read(ADDR, &reg, buf, 6);
     data->x = ((int16_t)buf[REG_DX_H - REG_DX_H] << 8) | buf[REG_DX_L - REG_DX_H];
     data->y = ((int16_t)buf[REG_DY_H - REG_DX_H] << 8) | buf[REG_DY_L - REG_DX_H];
     data->z = ((int16_t)buf[REG_DZ_H - REG_DX_H] << 8) | buf[REG_DZ_L - REG_DX_H];

extras/i2c/i2c.c

@@ -39,6 +39,7 @@
 
 static bool started;
 static bool flag;
+static bool force;
 static uint8_t freq ;
 static uint8_t g_scl_pin;
 static uint8_t g_sda_pin;
@@ -232,7 +233,13 @@ uint8_t i2c_read(bool ack)
     return byte;
 }
 
-static int i2c_bus_test(bool force)
+void i2c_force_bus(bool state)
+{
+    force = state ;
+}
+
+
+static int i2c_bus_test()
 {
     taskENTER_CRITICAL(); // To prevent task swaping after checking flag and before set it!
     bool status = flag ; // get current status
@@ -261,9 +268,9 @@ static int i2c_bus_test(bool force)
     return 0 ;
 }
 
-int i2c_slave_write(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len, bool force)
+int i2c_slave_write(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len)
 {
-    if(i2c_bus_test(force))
+    if(i2c_bus_test())
         return -EBUSY ;
     i2c_start();
     if (!i2c_write(slave_addr << 1))
@@ -287,9 +294,9 @@ int i2c_slave_write(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t le
     return -EIO;
 }
 
-int i2c_slave_read(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len, bool force)
+int i2c_slave_read(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len)
 {
-    if(i2c_bus_test(force))
+    if(i2c_bus_test())
         return -EBUSY ;
     if(data != NULL) {
         i2c_start();

extras/i2c/i2c.h

@@ -102,16 +102,21 @@ bool i2c_status(void);
 
 //Level 1 API (Don't need functions above)
 
+/**
+ * This function will allow you to force a transmission I2C, canceled the current one.
+ * @param state Force the next I2C transmission if true (Use with precaution)
+ */
+void i2c_force_bus(bool state);
+
 /**
  * Write 'len' bytes from 'buf' to slave at 'data' register adress .
  * @param slave_addr slave device address
  * @param data Pointer to register address to send if non-null
  * @param buf Pointer to data buffer
  * @param len Number of byte to send
- * @param force Force transaction if bus busy (use with precaution)
  * @return Non-Zero if error occured
  */
-int i2c_slave_write(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len, bool force);
+int i2c_slave_write(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len);
 
 /**
  * Issue a send operation of 'data' register adress, followed by reading 'len' bytes
@@ -120,10 +125,9 @@ int i2c_slave_write(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t le
  * @param data Pointer to register address to send if non-null
  * @param buf Pointer to data buffer
  * @param len Number of byte to read
- * @param force Force transaction if bus busy (use with precaution)
  * @return Non-Zero if error occured
  */
-int i2c_slave_read(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len, bool force);
+int i2c_slave_read(uint8_t slave_addr, uint8_t *data, uint8_t *buf, uint32_t len);
 
 #ifdef	__cplusplus
 }

extras/ina3221/ina3221.c

@@ -24,13 +24,13 @@ static int _wireWriteRegister (uint8_t addr, uint8_t reg, uint16_t value)
     d[1] = value  & 0x00FF;
     d[0] = (value >> 8) & 0x00FF;
     debug("Data write to %02X : %02X+%04X\n",addr,reg,value);
-    return i2c_slave_write(addr, &reg, d, sizeof(d), false);
+    return i2c_slave_write(addr, &reg, d, sizeof(d));
 }
 
 static int _wireReadRegister(uint8_t addr, uint8_t reg, uint16_t *value)
 {
     uint8_t d[] = {0, 0};
-    int error = i2c_slave_read(addr, &reg, d, sizeof(d), false)
+    int error = i2c_slave_read(addr, &reg, d, sizeof(d))
     debug("Data read from %02X: %02X+%04X\n",addr,reg,*value);
     *value = d[1] | (d[0] << 8);
     return error;

extras/mcp4725/mcp4725.c

@@ -14,7 +14,7 @@
 
 static void read_data(uint8_t addr, uint8_t *buf, uint8_t size)
 {
-    i2c_slave_read(addr, NULL, buf, size, false);
+    i2c_slave_read(addr, NULL, buf, size);
 }
 
 bool mcp4725_eeprom_busy(uint8_t addr)
@@ -41,7 +41,7 @@ void mcp4725_set_power_mode(uint8_t addr, mcp4725_power_mode_t mode, bool eeprom
         value >> 4,
         value << 4
     };
-    i2c_slave_write(addr, &data[0], &data[1], 2, false);
+    i2c_slave_write(addr, &data[0], &data[1], 2);
 }
 
 uint16_t mcp4725_get_raw_output(uint8_t addr, bool eeprom)
@@ -61,7 +61,7 @@ void mcp4725_set_raw_output(uint8_t addr, uint16_t value, bool eeprom)
         value >> 4,
         value << 4
     };
-    i2c_slave_write(addr, &data[0], &data[1], 2, false);
+    i2c_slave_write(addr, &data[0], &data[1], 2);
 }
 
 

extras/ms561101ba03/ms561101ba03.c

@@ -29,7 +29,7 @@
 static inline int reset(uint8_t addr)
 {
     uint8_t buf[1] = { RESET };
-    return i2c_slave_write(addr, NULL, buf, 1, false);
+    return i2c_slave_write(addr, NULL, buf, 1);
 }
 
 static inline bool read_prom(ms561101ba03_t *dev)
@@ -37,32 +37,32 @@ static inline bool read_prom(ms561101ba03_t *dev)
     uint8_t tmp[2] = { 0, 0 };
     uint8_t reg = 0xA2 ;
 
-    if (i2c_slave_read(dev->addr, &reg, tmp, 2, false))
+    if (i2c_slave_read(dev->addr, &reg, tmp, 2))
         return false;
     dev->config_data.sens = tmp[0] << 8 | tmp[1];
 
     reg = 0xA4 ;
-    if (i2c_slave_read(dev->addr, &reg, tmp, 2, false))
+    if (i2c_slave_read(dev->addr, &reg, tmp, 2))
         return false;
     dev->config_data.off = tmp[0] << 8 | tmp[1];
 
     reg = 0xA6 ;
-    if (i2c_slave_read(dev->addr, &reg, tmp, 2, false))
+    if (i2c_slave_read(dev->addr, &reg, tmp, 2))
         return false;
     dev->config_data.tcs = tmp[0] << 8 | tmp[1];
 
     reg = 0xA8 ;
-    if (i2c_slave_read(dev->addr, &reg, tmp, 2, false))
+    if (i2c_slave_read(dev->addr, &reg, tmp, 2))
         return false;
     dev->config_data.tco = tmp[0] << 8 | tmp[1];
 
     reg = 0xAA ;
-    if (i2c_slave_read(dev->addr, &reg, tmp, 2, false))
+    if (i2c_slave_read(dev->addr, &reg, tmp, 2))
         return false;
     dev->config_data.t_ref = tmp[0] << 8 | tmp[1];
 
     reg = 0xAC ;
-    if (i2c_slave_read(dev->addr, &reg, tmp, 2, false))
+    if (i2c_slave_read(dev->addr, &reg, tmp, 2))
         return false;
     dev->config_data.tempsens = tmp[0] << 8 | tmp[1];
 
@@ -72,13 +72,13 @@ static inline bool read_prom(ms561101ba03_t *dev)
 static inline int start_pressure_conversion(ms561101ba03_t *dev) //D1
 {
     uint8_t buf = CONVERT_D1 + dev->osr;
-    return i2c_slave_write(dev->addr, NULL, &buf, 1, false);
+    return i2c_slave_write(dev->addr, NULL, &buf, 1);
 }
 
 static inline int start_temperature_conversion(ms561101ba03_t *dev) //D2
 {
     uint8_t buf = CONVERT_D2 + dev->osr;
-    return i2c_slave_write(dev->addr, NULL, &buf, 1, false);
+    return i2c_slave_write(dev->addr, NULL, &buf, 1);
 }
 
 static inline bool read_adc(uint8_t addr, uint32_t *result)
@@ -86,7 +86,7 @@ static inline bool read_adc(uint8_t addr, uint32_t *result)
     *result = 0;
     uint8_t tmp[3];
     uint8_t reg = 0x00 ;
-    if (i2c_slave_read(addr, &reg, tmp, 3, false))
+    if (i2c_slave_read(addr, &reg, tmp, 3))
         return false;
 
     *result = (tmp[0] << 16) | (tmp[1] << 8) | tmp[2];

extras/pca9685/pca9685.c

@@ -61,14 +61,14 @@ inline static uint32_t round_div(uint32_t x, uint32_t y)
 
 inline static void write_reg(uint8_t addr, uint8_t reg, uint8_t val)
 {
-    if (i2c_slave_write(addr, &reg, &val, 1, false))
+    if (i2c_slave_write(addr, &reg, &val, 1))
         debug("Could not write 0x%02x to 0x%02x, addr = 0x%02x", reg, val, addr);
 }
 
 inline static uint8_t read_reg(uint8_t addr, uint8_t reg)
 {
     uint8_t res = 0;
-    if (i2c_slave_read(addr, &reg, &res, 1, false))
+    if (i2c_slave_read(addr, &reg, &res, 1))
         debug("Could not read from 0x%02x, addr = 0x%02x", reg, addr);
     return res;
 }
@@ -192,7 +192,7 @@ void pca9685_set_pwm_value(uint8_t addr, uint8_t channel, uint16_t val)
     {
         // Normal
         uint8_t buf[4] = { 0, 0, val, val >> 8 };
-        i2c_slave_write(addr, &reg, buf, 4, false);
+        i2c_slave_write(addr, &reg, buf, 4);
     }
     else
     {

extras/pcf8574/pcf8574.c

@@ -4,7 +4,7 @@
 uint8_t pcf8574_port_read(uint8_t addr)
 {
     uint8_t res;
-    if (i2c_slave_read(addr, NULL, &res, 1, false))
+    if (i2c_slave_read(addr, NULL, &res, 1))
             return 0;
     return res;
 }
@@ -14,7 +14,7 @@ size_t pcf8574_port_read_buf(uint8_t addr, void *buf, size_t len)
     if (!len || !buf) return 0;
     uint8_t *_buf = (uint8_t *)buf;
 
-    if (i2c_slave_read(addr, NULL, _buf, len, false))
+    if (i2c_slave_read(addr, NULL, _buf, len))
         return 0;
     return len;
 }
@@ -24,14 +24,14 @@ size_t pcf8574_port_write_buf(uint8_t addr, void *buf, size_t len)
     if (!len || !buf) return 0;
     uint8_t *_buf = (uint8_t *)buf;
 
-    if (i2c_slave_write(addr, NULL, _buf, len, false))
+    if (i2c_slave_write(addr, NULL, _buf, len))
         return 0;
     return len;
 }
 
 void pcf8574_port_write(uint8_t addr, uint8_t value)
 {
-    i2c_slave_write(addr, NULL, &value, 1, false);
+    i2c_slave_write(addr, NULL, &value, 1);
 }
 
 bool pcf8574_gpio_read(uint8_t addr, uint8_t num)

extras/ssd1306/ssd1306.c

@@ -92,7 +92,7 @@
 #if (SSD1306_I2C_SUPPORT)
 static int inline i2c_send(const ssd1306_t *dev, uint8_t reg, uint8_t* data, uint8_t len)
 {
-    return i2c_slave_write(dev->addr, &reg, data, len, false);
+    return i2c_slave_write(dev->addr, &reg, data, len);
 }
 #endif
 

extras/tsl2561/tsl2561.c

@@ -99,7 +99,7 @@
 static int write_register(uint8_t i2c_addr, uint8_t reg, uint8_t value)
 {
     reg = TSL2561_REG_COMMAND | reg;
-    return i2c_slave_write(i2c_addr, &reg, &value, 1, false);
+    return i2c_slave_write(i2c_addr, &reg, &value, 1);
 }
 
 static uint8_t read_register(uint8_t i2c_addr, uint8_t reg)
@@ -107,7 +107,7 @@ static uint8_t read_register(uint8_t i2c_addr, uint8_t reg)
     uint8_t data[1];
     reg = TSL2561_REG_COMMAND | reg;
 
-    if (i2c_slave_read(i2c_addr, &reg , data, 1, false))
+    if (i2c_slave_read(i2c_addr, &reg , data, 1))
     {
         printf("Error in tsl261 read_register\n");
     }
@@ -121,7 +121,7 @@ static uint16_t read_register_16(uint8_t i2c_addr, uint8_t low_register_addr)
     uint8_t data[2];
     low_register_addr = TSL2561_REG_COMMAND | TSL2561_READ_WORD | low_register_addr;
 
-    if (i2c_slave_read(i2c_addr, &low_register_addr, data, 2, false))
+    if (i2c_slave_read(i2c_addr, &low_register_addr, data, 2))
     {
         printf("Error with i2c_slave_read in read_register_16\n");
     }