Renamed from DuplexSlaveI2s to I2sSlaveDuplex.

To align with GpioBasic.

Author: suikan4github

README.md

@@ -13,7 +13,7 @@ These classes are provided in this version.
 | ::rpp_driver::[SdkWrapper](doc/sdkwrapper.md)         | Wrapper class of Pico SDK    |
 | ::rpp_driver::[GpioBasic](doc/gpiobasic.md)           | Basic GPIO controller        |
 | ::rpp_driver::[I2cMaster](doc/i2cmaster.md)           | I2C Master controller        |
-| ::rpp_driver::[DuplexSlaveI2s](doc/duplexslavei2s.md) | Polling based PIO I2S driver |
+| ::rpp_driver::[I2sSlaveDuplex](doc/duplexslavei2s.md) | Polling based PIO I2S driver |
 | ::rpp_driver::[Adau1361](doc/adau1361.md)             | Audio CODEC driver           |
 
 

doc/duplexslavei2s.md

@@ -1,4 +1,4 @@
-# ::rpp_driver::DuplexSlaveI2s class
+# ::rpp_driver::I2sSlaveDuplex class
 This is an experimental project for the Raspberry Pi Pico I2S implementation. This project targets : 
 - Supports Duplex I2S in Slave mode. 
 - Only 32bit data on I2S is supported. 

src/i2s/duplexslavei2s.cpp

@@ -10,35 +10,35 @@ extern "C" {
 static pio_program_t duplex_slave_i2s_program;
 #endif  // __has_include(<hardware/pio.h>)
 
-rpp_driver::DuplexSlaveI2s::DuplexSlaveI2s(::rpp_driver::SdkWrapper &sdk,
+rpp_driver::I2sSlaveDuplex::I2sSlaveDuplex(::rpp_driver::SdkWrapper &sdk,
                                            PIO pio, uint pin_base)
     : sdk_(sdk),
       pio_(pio),
       sm_(sdk_.pio_claim_unused_sm(
           pio_, true)),  // true mean required. assert if no room.
       pin_base_(pin_base) {}
 
-rpp_driver::DuplexSlaveI2s::DuplexSlaveI2s(::rpp_driver::SdkWrapper &sdk,
+rpp_driver::I2sSlaveDuplex::I2sSlaveDuplex(::rpp_driver::SdkWrapper &sdk,
                                            PIO pio, uint32_t sm, uint pin_base)
     : sdk_(sdk), pio_(pio), sm_(sm), pin_base_(pin_base) {
   sdk_.pio_sm_claim(pio_, sm_);
 }
 
-rpp_driver::DuplexSlaveI2s::~DuplexSlaveI2s() {
+rpp_driver::I2sSlaveDuplex::~I2sSlaveDuplex() {
   sdk_.pio_sm_unclaim(pio_, sm_);
 }
 
-uint32_t rpp_driver::DuplexSlaveI2s::GetStateMachine() { return sm_; }
+uint32_t rpp_driver::I2sSlaveDuplex::GetStateMachine() { return sm_; }
 
-int32_t rpp_driver::DuplexSlaveI2s::GetFifoBlocking() {
+int32_t rpp_driver::I2sSlaveDuplex::GetFifoBlocking() {
   return sdk_.pio_sm_get_blocking(pio_, sm_);
 }
 
-void rpp_driver::DuplexSlaveI2s::PutFifoBlocking(int32_t value) {
+void rpp_driver::I2sSlaveDuplex::PutFifoBlocking(int32_t value) {
   sdk_.pio_sm_put_blocking(pio_, sm_, value);
 }
 
-void rpp_driver::DuplexSlaveI2s::Start() {
+void rpp_driver::I2sSlaveDuplex::Start() {
   // Assign these pins for PIO by GPIO mux.
   sdk_.pio_gpio_init(pio_, pin_base_);
   sdk_.pio_gpio_init(pio_, pin_base_ + 1);
@@ -122,7 +122,7 @@ void rpp_driver::DuplexSlaveI2s::Start() {
   sdk_.pio_sm_set_enabled(pio_, sm_, true);
 }
 
-void rpp_driver::DuplexSlaveI2s::Stop() {
+void rpp_driver::I2sSlaveDuplex::Stop() {
   // Stop state machine.
   sdk_.pio_sm_set_enabled(pio_, sm_, false);
   // Clean up FIFO for the next processing.

src/i2s/duplexslavei2s.hpp

@@ -47,15 +47,15 @@ namespace rpp_driver {
  * This class assumes polling based data transfer instead of interrupt / DMA
  * based data transfer.
  */
-class DuplexSlaveI2s {
+class I2sSlaveDuplex {
  private:
   ::rpp_driver::SdkWrapper &sdk_;
   PIO pio_;
   const uint32_t sm_;    // State machine ( 0..3 )
   const uint pin_base_;  // first GPIO pin number of the I2S signal.
 
  public:
-  DuplexSlaveI2s(/* args */) = delete;
+  I2sSlaveDuplex(/* args */) = delete;
   /**
    * @brief Construct a new Duplex Slave I 2 S object
    *
@@ -67,7 +67,7 @@ class DuplexSlaveI2s {
    * Internally, the state machine will be allocate from the unused one.
    *
    */
-  DuplexSlaveI2s(::rpp_driver::SdkWrapper &sdk, PIO pio, uint pin_base);
+  I2sSlaveDuplex(::rpp_driver::SdkWrapper &sdk, PIO pio, uint pin_base);
   /**
    * @brief Construct a new Duplex Slave I 2 S object
    *
@@ -77,13 +77,13 @@ class DuplexSlaveI2s {
    * @param pin_base The GPIO pin number of SDOUT signal.
    * @details
    */
-  DuplexSlaveI2s(::rpp_driver::SdkWrapper &sdk, PIO pio, uint32_t sm,
+  I2sSlaveDuplex(::rpp_driver::SdkWrapper &sdk, PIO pio, uint32_t sm,
                  uint pin_base);
 
   /**
    * @brief Stop the state machine and make FIFO empty.
    */
-  ~DuplexSlaveI2s();
+  ~I2sSlaveDuplex();
 
   /**
    * @brief Initialize the I2S port, and run.
@@ -132,7 +132,7 @@ class DuplexSlaveI2s {
 
 #if __has_include(<gmock/gmock.h>)
 
-class MockDuplexSlaveI2s : public DuplexSlaveI2s {
+class MockI2sSlaveDuplex : public I2sSlaveDuplex {
  public:
   MOCK_METHOD0(GetStateMachine, uint32_t(void));
   MOCK_METHOD0(Start, void(void));

test/test_duplexslavei2s.cpp

@@ -6,25 +6,25 @@
 #include "duplexslavei2s.hpp"
 #include "sdkwrapper.hpp"
 
-class DuplexSlaveI2sTest : public ::testing::Test {
+class I2sSlaveDuplexTest : public ::testing::Test {
  protected:
   std::random_device rng;
   ::rpp_driver::MockSdkWrapper sdk_;
   PIO pio_ = rng();
   uint32_t sm_ = rng();
   uint pin_base_ = rng();
-  ::rpp_driver::DuplexSlaveI2s *i2s_;
+  ::rpp_driver::I2sSlaveDuplex *i2s_;
 };
 
 // Test 4 parameters constructor.
-TEST_F(DuplexSlaveI2sTest, Constructor4) {
+TEST_F(I2sSlaveDuplexTest, Constructor4) {
   using ::testing::_;
   using ::testing::Return;
 
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
   EXPECT_CALL(sdk_, pio_claim_unused_sm(_, _)).Times(0);
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   // must be matched with Externally given SM.
   EXPECT_EQ(sm_, i2s_->GetStateMachine());
@@ -34,18 +34,18 @@ TEST_F(DuplexSlaveI2sTest, Constructor4) {
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, Constructor4)
+}  // TEST_F(I2sSlaveDuplexTest, Constructor4)
 
 // Test 3 parameters constructor.
-TEST_F(DuplexSlaveI2sTest, Constructor3) {
+TEST_F(I2sSlaveDuplexTest, Constructor3) {
   std::random_device rng;
   using ::testing::_;
   using ::testing::Return;
   const uint ret_val = rng();
 
   EXPECT_CALL(sdk_, pio_claim_unused_sm(pio_, true)).WillOnce(Return(ret_val));
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, pin_base_);
 
   // must be matched with Internally Registered SM.
   EXPECT_EQ(ret_val, i2s_->GetStateMachine());
@@ -54,10 +54,10 @@ TEST_F(DuplexSlaveI2sTest, Constructor3) {
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, Constructor3)
+}  // TEST_F(I2sSlaveDuplexTest, Constructor3)
 
 // Test Destructor
-TEST_F(DuplexSlaveI2sTest, Destructor) {
+TEST_F(I2sSlaveDuplexTest, Destructor) {
   std::random_device rng;
   using ::testing::_;
   using ::testing::Return;
@@ -66,16 +66,16 @@ TEST_F(DuplexSlaveI2sTest, Destructor) {
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
   EXPECT_CALL(sdk_, pio_claim_unused_sm(_, _)).Times(0);
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   EXPECT_CALL(sdk_, pio_sm_unclaim(pio_, sm_));
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, Destructor)
+}  // TEST_F(I2sSlaveDuplexTest, Destructor)
 
 // Test Destructor with stopped state machine
-TEST_F(DuplexSlaveI2sTest, Destructor_stopped) {
+TEST_F(I2sSlaveDuplexTest, Destructor_stopped) {
   std::random_device rng;
   using ::testing::_;
   using ::testing::InSequence;
@@ -85,7 +85,7 @@ TEST_F(DuplexSlaveI2sTest, Destructor_stopped) {
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
   EXPECT_CALL(sdk_, pio_claim_unused_sm(_, _)).Times(0);
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   {
     InSequence dummy;
@@ -100,9 +100,9 @@ TEST_F(DuplexSlaveI2sTest, Destructor_stopped) {
   }
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, Destructor_stopped)
+}  // TEST_F(I2sSlaveDuplexTest, Destructor_stopped)
 
-TEST_F(DuplexSlaveI2sTest, Stop) {
+TEST_F(I2sSlaveDuplexTest, Stop) {
   std::random_device rng;
   using ::testing::_;
   using ::testing::Return;
@@ -111,7 +111,7 @@ TEST_F(DuplexSlaveI2sTest, Stop) {
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
   EXPECT_CALL(sdk_, pio_claim_unused_sm(_, _)).Times(0);
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   EXPECT_CALL(sdk_, pio_sm_set_enabled(pio_, sm_, false));
   EXPECT_CALL(sdk_, pio_sm_clear_fifos(pio_, sm_));
@@ -124,17 +124,17 @@ TEST_F(DuplexSlaveI2sTest, Stop) {
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, Stop)
+}  // TEST_F(I2sSlaveDuplexTest, Stop)
 
-TEST_F(DuplexSlaveI2sTest, GetStateMachine) {
+TEST_F(I2sSlaveDuplexTest, GetStateMachine) {
   std::random_device rng;
   using ::testing::_;
   using ::testing::Return;
 
   // We can ignore these call in constructor.
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   // Must match the given state machine from constructor explicitly.
   EXPECT_EQ(i2s_->GetStateMachine(), sm_);
@@ -144,9 +144,9 @@ TEST_F(DuplexSlaveI2sTest, GetStateMachine) {
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, GetStateMachine)
+}  // TEST_F(I2sSlaveDuplexTest, GetStateMachine)
 
-TEST_F(DuplexSlaveI2sTest, Start) {
+TEST_F(I2sSlaveDuplexTest, Start) {
   using ::testing::_;
   using ::testing::InSequence;
   using ::testing::Return;
@@ -157,7 +157,7 @@ TEST_F(DuplexSlaveI2sTest, Start) {
   // We can ignore these call in constructor.
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   {
     InSequence dummy;
@@ -210,9 +210,9 @@ TEST_F(DuplexSlaveI2sTest, Start) {
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, Start)
+}  // TEST_F(I2sSlaveDuplexTest, Start)
 
-TEST_F(DuplexSlaveI2sTest, GetFifoBlocking) {
+TEST_F(I2sSlaveDuplexTest, GetFifoBlocking) {
   std::random_device rng;
   int32_t ret_val = rng();
   using ::testing::_;
@@ -221,7 +221,7 @@ TEST_F(DuplexSlaveI2sTest, GetFifoBlocking) {
   // We can ignore these call in constructor.
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   EXPECT_CALL(sdk_, pio_sm_get_blocking(pio_, sm_)).WillOnce(Return(ret_val));
 
@@ -233,9 +233,9 @@ TEST_F(DuplexSlaveI2sTest, GetFifoBlocking) {
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, GetFifoBlocking)
+}  // TEST_F(I2sSlaveDuplexTest, GetFifoBlocking)
 
-TEST_F(DuplexSlaveI2sTest, PutFifoBlocking) {
+TEST_F(I2sSlaveDuplexTest, PutFifoBlocking) {
   std::random_device rng;
   int32_t value = rng();
   using ::testing::_;
@@ -244,7 +244,7 @@ TEST_F(DuplexSlaveI2sTest, PutFifoBlocking) {
   // We can ignore these call in constructor.
   EXPECT_CALL(sdk_, pio_sm_claim(pio_, sm_));
 
-  i2s_ = new ::rpp_driver::DuplexSlaveI2s(sdk_, pio_, sm_, pin_base_);
+  i2s_ = new ::rpp_driver::I2sSlaveDuplex(sdk_, pio_, sm_, pin_base_);
 
   EXPECT_CALL(sdk_, pio_sm_put_blocking(pio_, sm_, value));
 
@@ -256,4 +256,4 @@ TEST_F(DuplexSlaveI2sTest, PutFifoBlocking) {
 
   delete (i2s_);
 
-}  // TEST_F(DuplexSlaveI2sTest, PutFifoBlocking)
+}  // TEST_F(I2sSlaveDuplexTest, PutFifoBlocking)

test/todo/test_duplexslavei2s.md

@@ -1,46 +1,46 @@
-# test_DuplexSlaveI2s TDD
-- [x] Implement DuplexSlaveI2s::PutFifoBlocking(). 
-- [x] Create Test case DuplexSlaveI2s.PUtFIFOBlocking() to fail. 
+# test_I2sSlaveDuplex TDD
+- [x] Implement I2sSlaveDuplex::PutFifoBlocking(). 
+- [x] Create Test case I2sSlaveDuplex.PUtFIFOBlocking() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
-- [x] Implement DuplexSlaveI2s::GetFifoBlocking(). 
-- [x] Create Test case DuplexSlaveI2s.GetFifoBlocking() to fail. 
+- [x] Implement I2sSlaveDuplex::GetFifoBlocking(). 
+- [x] Create Test case I2sSlaveDuplex.GetFifoBlocking() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
 
-- [x] Implement DuplexSlaveI2s::GetStateMachine(). 
+- [x] Implement I2sSlaveDuplex::GetStateMachine(). 
 - [x] Create Test case SdkWrapper.GetStateMachine() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
-- [x] Implement DuplexSlaveI2s::Start(). 
+- [x] Implement I2sSlaveDuplex::Start(). 
 - [x] Create Test case SdkWrapper.Start() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
-- [x] Implement DuplexSlaveI2s::Stop(). 
+- [x] Implement I2sSlaveDuplex::Stop(). 
 - [x] Create Test case SdkWrapper.Stop() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
-- [x] Implement DuplexSlaveI2s::Constructor3(). 
+- [x] Implement I2sSlaveDuplex::Constructor3(). 
 - [x] Create Test case SdkWrapper.Constructor3() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
-- [4] Implement DuplexSlaveI2s::Constructor4(). 
+- [4] Implement I2sSlaveDuplex::Constructor4(). 
 - [x] Create Test case SdkWrapper.Constructor4() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
-- [x] Implement DuplexSlaveI2s::Destructor(). 
+- [x] Implement I2sSlaveDuplex::Destructor(). 
 - [x] Create Test case SdkWrapper.Destructor() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication. 
 
-- [x] Implement DuplexSlaveI2s::Destructor_stopped(). 
+- [x] Implement I2sSlaveDuplex::Destructor_stopped(). 
 - [x] Create Test case SdkWrapper.Destructor_stopped() to fail. 
 - [x] Make it success. 
 - [x] Remove the duplication.