[driver] Refactor all I2C driver to use fibers

Author: salkinium

src/modm/architecture/interface/i2c_device.hpp

@@ -15,7 +15,7 @@
 #include "i2c.hpp"
 #include "i2c_master.hpp"
 #include "i2c_transaction.hpp"
-#include <modm/processing/resumable.hpp>
+#include <modm/processing/fiber.hpp>
 
 namespace modm
 {
@@ -41,7 +41,7 @@ namespace modm
  * @ingroup modm_architecture_i2c_device
  */
 template < class I2cMaster, uint8_t NestingLevels = 10, class Transaction = I2cWriteReadTransaction >
-class I2cDevice : protected modm::NestedResumable< NestingLevels + 1 >
+class I2cDevice
 {
 public:
 	///	@param	address	the slave address not yet shifted left (address < 128).
@@ -60,69 +60,49 @@ class I2cDevice : protected modm::NestedResumable< NestingLevels + 1 >
 
 	/// Attaches a configuration handler, which is called before a transaction,
 	/// whenever the configuration has to be changed.
-	void inline
+	void
 	attachConfigurationHandler(I2c::ConfigurationHandler handler)
 	{
 		configuration = handler;
 	}
 
 	/// @retval true	device responds to address
 	/// @retval false	no device with address found
-	modm::ResumableResult<bool>
+	bool
 	ping()
 	{
-		RF_BEGIN();
-
-		RF_WAIT_UNTIL( transaction.configurePing() and startTransaction() );
-
-		RF_WAIT_WHILE( isTransactionRunning() );
-
-		RF_END_RETURN( wasTransactionSuccessful() );
+		modm::this_fiber::poll([&]{ return transaction.configurePing(); });
+		return runTransaction();
 	}
 
 	/// Starts a write-read transaction and waits until finished.
-	modm::ResumableResult<bool>
+	bool
 	writeRead(const uint8_t *writeBuffer, std::size_t writeSize,
 			  uint8_t *readBuffer, std::size_t readSize)
 	{
-		RF_BEGIN();
-
-		RF_WAIT_UNTIL( startWriteRead(writeBuffer, writeSize, readBuffer, readSize) );
-
-		RF_WAIT_WHILE( isTransactionRunning() );
-
-		RF_END_RETURN( wasTransactionSuccessful() );
+		modm::this_fiber::poll([&]{ return transaction.configureWriteRead(writeBuffer, writeSize, readBuffer, readSize); });
+		return runTransaction();
 	}
 
 	/// Starts a write transaction and waits until finished.
-	modm::ResumableResult<bool>
+	bool
 	write(const uint8_t *buffer, std::size_t size)
 	{
-		RF_BEGIN();
-
-		RF_WAIT_UNTIL( startWrite(buffer, size) );
-
-		RF_WAIT_WHILE( isTransactionRunning() );
-
-		RF_END_RETURN( wasTransactionSuccessful() );
+		modm::this_fiber::poll([&]{ return transaction.configureWrite(buffer, size); });
+		return runTransaction();
 	}
 
 	/// Starts a write transaction and waits until finished.
-	modm::ResumableResult<bool>
+	bool
 	read(uint8_t *buffer, std::size_t size)
 	{
-		RF_BEGIN();
-
-		RF_WAIT_UNTIL( startRead(buffer, size) );
-
-		RF_WAIT_WHILE( isTransactionRunning() );
-
-		RF_END_RETURN( wasTransactionSuccessful() );
+		modm::this_fiber::poll([&]{ return transaction.configureRead(buffer, size); });
+		return runTransaction();
 	}
 
 protected:
 	/// Configures the transaction with a write/read operation and starts it.
-	bool inline
+	bool
 	startWriteRead(const uint8_t *writeBuffer, std::size_t writeSize,
 			uint8_t *readBuffer, std::size_t readSize)
 	{
@@ -131,15 +111,15 @@ class I2cDevice : protected modm::NestedResumable< NestingLevels + 1 >
 	}
 
 	/// Configures the transaction with a write operation and starts it.
-	bool inline
+	bool
 	startWrite(const uint8_t *buffer, std::size_t size)
 	{
 		return ( transaction.configureWrite(buffer, size) and
 				startTransaction() );
 	}
 
 	/// Configures the transaction with a read operation and starts it.
-	bool inline
+	bool
 	startRead(uint8_t *buffer, std::size_t size)
 	{
 		return ( transaction.configureRead(buffer, size) and
@@ -148,44 +128,40 @@ class I2cDevice : protected modm::NestedResumable< NestingLevels + 1 >
 
 protected:
 	/// Starts the transaction with our own transaction object.
-	bool inline
+	bool
 	startTransaction()
 	{
 		return startTransaction(&this->transaction);
 	}
 
 	/// Starts the transaction with a separate transaction object.
-	bool inline
+	bool
 	startTransaction(modm::I2cTransaction *transaction)
 	{
 		return I2cMaster::start(transaction, configuration);
 	}
 
 	/// @returns `true` when transaction is busy.
-	bool inline
+	bool
 	isTransactionRunning()
 	{
 		return transaction.isBusy();
 	}
 
 	/// @returns `true` when transaction did not return an error.
-	bool inline
+	bool
 	wasTransactionSuccessful()
 	{
 		return (transaction.getState() != modm::I2c::TransactionState::Error);
 	}
 
 	/// Starts our own transaction and waits until finished.
-	modm::ResumableResult<bool>
+	bool
 	runTransaction()
 	{
-		RF_BEGIN();
-
-		RF_WAIT_UNTIL( startTransaction() );
-
-		RF_WAIT_WHILE( isTransactionRunning() );
-
-		RF_END_RETURN( wasTransactionSuccessful() );
+		modm::this_fiber::poll([&]{ return startTransaction(); });
+		modm::this_fiber::poll([&]{ return not isTransactionRunning(); });
+		return wasTransactionSuccessful();
 	}
 
 protected:

src/modm/architecture/module.lb

@@ -234,7 +234,7 @@ class I2cDevice(Module):
         module.description = "I²C Devices"
 
     def prepare(self, module, options):
-        module.depends(":architecture:i2c", ":processing:resumable")
+        module.depends(":architecture:i2c", ":architecture:fiber")
         return True
 
     def build(self, env):

src/modm/driver/adc/ads101x.hpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2022, Jonas Kazem Andersen
  * Copyright (c) 2022, Rasmus Kleist Hørlyck Sørensen
+ * Copyright (c) 2025, Niklas Hauser
  *
  * This file is part of the modm project.
  *
@@ -10,10 +11,10 @@
  */
 // ----------------------------------------------------------------------------
 
-#ifndef MODM_ADS101X_HPP
-#define MODM_ADS101X_HPP
+#pragma once
 
 #include <modm/architecture/interface/i2c_device.hpp>
+#include <modm/architecture/interface/register.hpp>
 
 namespace modm
 {
@@ -187,62 +188,118 @@ struct ads101x
  * @ingroup modm_driver_ads101x
  */
 template <typename I2cMaster>
-class Ads101x : public ads101x, public modm::I2cDevice<I2cMaster, 2>
+class Ads101x : public ads101x, public modm::I2cDevice<I2cMaster>
 {
 public:
     /**
      * @param data
      * @param address
      */
-    Ads101x(Data &data, uint8_t address = 0x49);
+    Ads101x(Data &data, uint8_t address = 0x49)
+    : I2cDevice<I2cMaster>(address), data(data) {}
 
     /// Call this function before using the device
-    modm::ResumableResult<bool>
-    initialize();
+    bool
+    initialize()
+    {
+        InputMultiplexer_t::set(config, InputMultiplexer::Input0);
+        FullScaleRange_t::set(config, FullScaleRange::V2_048);
+        DeviceOperatingMode_t::set(config, DeviceOperatingMode::SingleShot);
+        DataRate_t::set(config, DataRate::Sps1600);
+        ComparatorQueue_t::set(config, ComparatorQueue::Disable);
+        data.lsbSizeIndex = i(FullScaleRange::V2_048) >> 9;
+
+        return writeRegister(Register::Config, config.value);
+    }
 
     /// Determine if the device is currently performing a conversion
-    modm::ResumableResult<bool>
-    isBusy();
+    bool
+    isBusy()
+    {
+        uint8_t buffer[2] = {i(Register::Config)};
+        if (not this->writeRead(buffer, 1, buffer, 2)) return false;
+        return not ((uint16_t(buffer[0]) << 8) & i(ConfigRegister::OS));
+    }
 
     /// Start a single conversion with the specified input
-    modm::ResumableResult<bool>
-    startSingleShotConversion();
+    bool
+    startSingleShotConversion()
+    {
+        DeviceOperatingMode_t::set(config, DeviceOperatingMode::SingleShot);
+        return writeRegister(Register::Config, i(ConfigRegister::OS) | config.value);
+    }
 
     /// Start continuous conversions with the specified datarate and input
-    modm::ResumableResult<bool>
-    startContinuousConversion(DataRate dataRate = DataRate::Sps1600);
+    bool
+    startContinuousConversion(DataRate dataRate = DataRate::Sps1600)
+    {
+        DataRate_t::set(config, dataRate);
+        DeviceOperatingMode_t::set(config, DeviceOperatingMode::Continuous);
+        return writeRegister(Register::Config, i(ConfigRegister::OS) | config.value);
+    }
 
     /// Start a single conversion with the specified input
     /// @warning ADS1015 only
-    modm::ResumableResult<bool>
-    startSingleShotConversion(InputMultiplexer input = InputMultiplexer::Input0);
+    bool
+    startSingleShotConversion(InputMultiplexer input = InputMultiplexer::Input0)
+    {
+        InputMultiplexer_t::set(config, input);
+        DeviceOperatingMode_t::set(config, DeviceOperatingMode::SingleShot);
+        return writeRegister(Register::Config, i(ConfigRegister::OS) | config.value);
+    }
 
     /// Start continuous conversions with the specified datarate and input
     /// @warning ADS1015 only
-    modm::ResumableResult<bool>
-    startContinuousConversion(InputMultiplexer input = InputMultiplexer::Input0, DataRate dataRate = DataRate::Sps1600);
+    bool
+    startContinuousConversion(InputMultiplexer input = InputMultiplexer::Input0, DataRate dataRate = DataRate::Sps1600)
+    {
+        DataRate_t::set(config, dataRate);
+        InputMultiplexer_t::set(config, input);
+        DeviceOperatingMode_t::set(config, DeviceOperatingMode::Continuous);
+        return writeRegister(Register::Config, config.value);
+    }
 
     /// Read the last conversion result
     /// @attention Following power-up, the conversion result remains zero until the first conversion is completed
-    modm::ResumableResult<bool>
-    readConversionResult();
+    bool
+    readConversionResult()
+    {
+        uint8_t buffer = i(Register::Conversion);
+        return this->writeRead(&buffer, 1, data.data, 2);
+    }
 
     /// Enable the conversion-ready function of the ALERT/RDY pin
     /// @attention enabling the conversion-ready function disables the comparator and sets the ComparatorQue value to one conversion
-    modm::ResumableResult<bool>
-    enableConversionReadyFunction();
+    bool
+    enableConversionReadyFunction()
+    {
+        if (not (writeRegister(Register::LowThreshold, 0x0000) and
+                 writeRegister(Register::HighThreshold, 0xFFFF)))
+            return false;
+
+        ComparatorQueue_t::set(config, ComparatorQueue::OneConversion);
+        return writeRegister(Register::Config, config.value);
+    }
 
     /// Enable the comparator
     /// @warning ADS1014 and ADS1015 only
     /// @warning To use the comparator-function the high threshold must be greater than the low threshold
-    modm::ResumableResult<bool>
-    enableComparator(ComparatorMode mode, ComparatorPolarity polarity, ComparatorLatch latch, ComparatorQueue queue);
+    bool
+    enableComparator(ComparatorMode mode, ComparatorPolarity polarity, ComparatorLatch latch, ComparatorQueue queue)
+    {
+        ComparatorMode_t::set(config, mode);
+        ComparatorPolarity_t::set(config, polarity);
+        ComparatorLatch_t::set(config, latch);
+        ComparatorQueue_t::set(config, queue);
+
+        return writeRegister(Register::Config, config.value);
+    }
 
     /// Set the low threshold used by the comparator queue
     /// @warning ADS1014 and ADS1015 only
     /// @warning The low threshold value must be smaller than the high threshold value
     /// @attention The high threshold value must be updated whenever the PGA settings are changed
-    modm::ResumableResult<bool>
+    bool
     setLowThreshold(uint16_t threshold)
     {
         return writeRegister(Register::LowThreshold, (threshold << 4) & 0xFFF0);
@@ -252,31 +309,33 @@ class Ads101x : public ads101x, public modm::I2cDevice<I2cMaster, 2>
     /// @warning ADS1014 and ADS1015 only
     /// @warning The high threshold value must be greater than the low threshold value
     /// @attention The high threshold value must be updated whenever the PGA settings are changed
-    modm::ResumableResult<bool>
+    bool
     setHighThreshold(uint16_t threshold)
     {
         return writeRegister(Register::HighThreshold, (threshold << 4) | 0x0F);
     }
 
     /// Set the full scale range by programming the PGA and corresponding LSB size
-    modm::ResumableResult<bool>
-    setFullScaleRange(FullScaleRange fullScaleRange);
+    bool
+    setFullScaleRange(FullScaleRange fullScaleRange)
+    {
+        FullScaleRange_t::set(config, fullScaleRange);
+        data.lsbSizeIndex = i(fullScaleRange) >> 9;
+        return writeRegister(Register::Config, config.value);
+    }
 
 private:
-    modm::ResumableResult<bool>
-    writeRegister(Register reg, uint16_t data);
+    bool
+    writeRegister(Register reg, uint16_t data)
+    {
+        uint8_t buffer[] = {i(reg), data >> 8, data};
+        return this->write(buffer, sizeof(buffer));
+    }
 
     Data &data;
 
-    /// Command buffer for writing to device
-    uint8_t buffer[3];
-
     /// Configuration variable for writing to the configuration register
     ConfigRegister_t config;
 };
 
 }
-
-#include "ads101x_impl.hpp"
-
-#endif // MODM_ADS101X_HPP

src/modm/driver/adc/ads101x.lb

@@ -27,4 +27,3 @@ def prepare(module, options):
 def build(env):
     env.outbasepath = "modm/src/modm/driver/adc"
     env.copy("ads101x.hpp")
-    env.copy("ads101x_impl.hpp")