提交: c12f9258baee7f46ef7950f09e7734f98ed36b0d - shared_foo (git)

テスト用のあれこれ共用フォルダ

Commit MetaInfo

• 修訂: c12f9258baee7f46ef7950f09e7734f98ed36b0d (tree)
• 時間: 2018-09-22 16:46:15
• 作者: takemasa <suikan@user...>
• Commiter: takemasa

Log Message

Make error handling of the SPI error handling.

All error is now passed to application. And if the error is
unknown, it re-initialize the SPI.

Beside of SPI, some I2C syslog are changed.

Change Summary

• modified: stm32_development/murasaki/murasaki/abstractspimaster.hpp
• modified: stm32_development/murasaki/murasaki/i2cmaster.cpp
• modified: stm32_development/murasaki/murasaki/i2cmaster.hpp
• modified: stm32_development/murasaki/murasaki/murasaki_defs.hpp
• modified: stm32_development/murasaki/murasaki/spimaster.cpp
• modified: stm32_development/murasaki/murasaki/spimaster.hpp
• modified: stm32_development/nucleo-l152re-fujitsubo-test/nucleo-l152re-fujitsubo-test Debug.cfg

差異

--- a/stm32_development/murasaki/murasaki/abstractspimaster.hpp
+++ b/stm32_development/murasaki/murasaki/abstractspimaster.hpp
@@ -33,7 +33,7 @@ class AbstractSpiMaster:public murasaki::AbstractPeripheral
      * @param timeout_ms Timeout limit [mS]
      * @return true if transfer complete, false if timeout
      */
-    virtual bool TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier * spi_spec,
+    virtual SpiStatus TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier * spi_spec,
 			const uint8_t * tx_data,
             uint8_t * rx_data, unsigned int size,
 			murasaki::WaitMilliSeconds timeout_ms = murasaki::kwmsIndefinitely)=0;

--- a/stm32_development/murasaki/murasaki/i2cmaster.cpp
+++ b/stm32_development/murasaki/murasaki/i2cmaster.cpp
@@ -46,7 +46,6 @@ murasaki::I2cStatus I2cMaster::Transmit(
                                         const uint8_t* tx_data,
                                         unsigned int tx_size,
                                         WaitMilliSeconds timeout_ms) {
-    murasaki::I2cStatus result;
 
     I2C_SYSLOG("Enter");
 
@@ -90,12 +89,11 @@ murasaki::I2cStatus I2cMaster::Transmit(
                 MURASAKI_SYSLOG(kfaI2cMaster, kseEmergency, "Error is not handled")
 
         }
-        result = interrupt_status_;
     }
     critical_section_->Leave();
 
     I2C_SYSLOG("Return");
-    return result;
+    return interrupt_status_;
 }
 
 murasaki::I2cStatus I2cMaster::Receive(
@@ -103,7 +101,6 @@ murasaki::I2cStatus I2cMaster::Receive(
                                        uint8_t* rx_data,
                                        unsigned int rx_size,
                                        WaitMilliSeconds timeout_ms) {
-    murasaki::I2cStatus result;
 
     I2C_SYSLOG("Enter");
 
@@ -149,13 +146,12 @@ murasaki::I2cStatus I2cMaster::Receive(
                 MURASAKI_SYSLOG(kfaI2cMaster, kseEmergency, "Error is not handled")
 
         }
-        result = interrupt_status_;
 
     }
     critical_section_->Leave();
 
     I2C_SYSLOG("Return");
-    return result;
+    return interrupt_status_;
 }
 
 murasaki::I2cStatus I2cMaster::TransmitThenReceive(
@@ -255,15 +251,11 @@ murasaki::I2cStatus I2cMaster::TransmitThenReceive(
 
         }
 
-        result = interrupt_status_;
-
-
-
     }
     critical_section_->Leave();
 
     I2C_SYSLOG("Return");
-    return result;  // return false if timeout
+    return interrupt_status_;  // return false if timeout
 }
 
 bool I2cMaster::TransmitCompleteCallback(void* ptr) {
@@ -315,21 +307,21 @@ bool I2cMaster::HandleError(void* ptr) {
     if (peripheral_ == ptr) {
         // Check error and halde it.
         if (peripheral_->ErrorCode & HAL_I2C_ERROR_AF) {
-            I2C_SYSLOG("HAL_I2C_ERROR_AF");
+            MURASAKI_SYSLOG(kfaI2cMaster, kseWarning, "HAL_I2C_ERROR_AF");
             // This interrupt happen when device doesn't respond or return NAK.
             interrupt_status_ = murasaki::ki2csNak;
             // abort the processing
             sync_->Release();
         }
         else if (peripheral_->ErrorCode & HAL_I2C_ERROR_BERR) {
-            I2C_SYSLOG("HAL_I2C_ERROR_BERR");
+            MURASAKI_SYSLOG(kfaI2cMaster, kseWarning, "HAL_I2C_ERROR_BERR");
             // This interrupt happen when device
             interrupt_status_ = murasaki::ki2csBussError;
             // abort the processing
             sync_->Release();
         }
         else if (peripheral_->ErrorCode & HAL_I2C_ERROR_ARLO) {
-            I2C_SYSLOG("HAL_I2C_ERROR_ARLO");
+            MURASAKI_SYSLOG(kfaI2cMaster, kseWarning, "HAL_I2C_ERROR_ARLO");
             // This interrupt happen when device
             interrupt_status_ = murasaki::ki2csArbitrationLost;
             // abort the processing
@@ -338,12 +330,8 @@ bool I2cMaster::HandleError(void* ptr) {
         else {
             MURASAKI_SYSLOG(kfaI2cMaster, kseEmergency, "Error is not handled");
 
-            MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_I2C_ERROR_BERR);      // handled in "if" clause
-            MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_I2C_ERROR_ARLO);      // handled in "if" clause
-            MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_I2C_ERROR_AF);        // handled in "if" clause
             MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_I2C_ERROR_OVR);       // Doesn't occur in master
             MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_I2C_ERROR_DMA);       // Doesn't occur in this implemenattion
-            MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_I2C_ERROR_TIMEOUT);   // Doesn't occur in this implemenattion
 #ifdef         HAL_I2C_ERROR_SIZE
             MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_I2C_ERROR_SIZE);
 #endif

--- a/stm32_development/murasaki/murasaki/i2cmaster.hpp
+++ b/stm32_development/murasaki/murasaki/i2cmaster.hpp
@@ -63,6 +63,15 @@ namespace murasaki {
  *
  * Both methods can be called from only the task context. If these are called in the ISR
  * context, the result is unknown.
+ *
+ *  * Note : In case an time out occurs during transmit / receive, this implementation
+ * casells HAL_I2C_MASTER_ABORT_IT(). But it is unknown whether this is right thing to do.
+ * The HAL reference of the STM32F7 is not clear for this case. For example, it doesn't tell
+ * what programmer do to stop the transfer at the middle. And also, it doesn't tell what's happen
+ * if the HAL_I2C_MASTER_ABORT_IT() is called.
+ *
+ * According to the source code of the HAL_I2C_MASTER_ABORT_IT(), no interrupt will be
+ * raised by this API call.
  */
 class I2cMaster : public AbstractI2CMaster
 {

--- a/stm32_development/murasaki/murasaki/murasaki_defs.hpp
+++ b/stm32_development/murasaki/murasaki/murasaki_defs.hpp
@@ -208,7 +208,8 @@ enum SpiStatus
     kspisOverflow,              //!< Over run.
     kspisFrameError,            //!< Error on TI frame mode.
     kspisDMA,                   //!< DMA error
-    kspisErrorFlag              //!< Other error flag.
+    kspisErrorFlag,             //!< Other error flag.
+    kspisAbort                  //!< Problem in abort process. No way to recover.
 };
 
 

--- a/stm32_development/murasaki/murasaki/spimaster.cpp
+++ b/stm32_development/murasaki/murasaki/spimaster.cpp
@@ -41,13 +41,12 @@ SpiMaster::~SpiMaster()
 
 }
 
-bool SpiMaster::TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier* spi_spec,
+SpiStatus SpiMaster::TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier* spi_spec,
                          const uint8_t* tx_data,
                          uint8_t* rx_data,
                          unsigned int size,
                          murasaki::WaitMilliSeconds timeout_ms)
 {
-    bool result;
 
     SPIM_SYSLOG("Enter");
 
@@ -61,6 +60,9 @@ bool SpiMaster::TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier* spi_spec
     {
         SPIM_SYSLOG("Start re-configuring SPI master");
 
+        // This value will be updated by TransmitAndReceiveCompleteCallback
+        interrupt_status_ = murasaki::kspisTimeOut;
+
         // Change the clock porarity & phase
         // todo is following right?
         MURASAKI_ASSERT(HAL_SPI_DeInit(peripheral_) == HAL_OK);
@@ -91,7 +93,28 @@ bool SpiMaster::TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier* spi_spec
             MURASAKI_ASSERT(HAL_OK == status);
 
             // wait for the completion
-            result = sync_->Wait(timeout_ms);   // return false if timeout
+            sync_->Wait(timeout_ms);   // return false if timeout
+            SPIM_SYSLOG("Sync released.")
+
+            // check the status from interrupt
+            switch (interrupt_status_)
+            {
+                case murasaki::kspisOK:
+                    SPIM_SYSLOG("Receive complete successfully")
+                    break;
+                case murasaki::ki2csTimeOut:
+                    MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "Receive timeout")
+                    // Abort on-going and not terminated transfer.
+                    HAL_SPI_DMAStop(peripheral_);
+                    break;
+                default:
+                    MURASAKI_SYSLOG(kfaI2cMaster, kseEmergency, "Error is not handled")
+                    SPIM_SYSLOG("Re-initialize the SPI")
+                    // Desable SPI to try to clear the current error status. Then, re-enable.
+                    HAL_SPI_DeInit(peripheral_);
+                    HAL_SPI_Init(peripheral_);
+
+            }
 
             SPIM_SYSLOG("End SPI master transferring");
         }
@@ -101,7 +124,7 @@ bool SpiMaster::TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier* spi_spec
     critical_section_->Leave();
 
     SPIM_SYSLOG("Return");
-    return result;
+    return interrupt_status_;
 
 }
 
@@ -114,12 +137,17 @@ bool SpiMaster::TransmitAndReceiveCompleteCallback(void* ptr)
     // if matches, release task
     if (peripheral_ == ptr) {
         SPIM_SYSLOG("Release sync");
+        // report normal completion
+        interrupt_status_ = murasaki::kspisOK;
+        // release waiting task
         sync_->Release();
         SPIM_SYSLOG("Return");
+        // This interrupt is for this device.
         return true;
     }
     else {
         SPIM_SYSLOG("Return");
+        // This interrupt is not for this device.
         return false;
     }
 }
@@ -131,16 +159,57 @@ bool SpiMaster::HandleError(void* ptr)
     MURASAKI_ASSERT(nullptr != ptr)
 
     if (peripheral_ == ptr) {
-        // Check error, and print if exist.
-        MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_SPI_ERROR_MODF);
-        MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_SPI_ERROR_CRC);
-        MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_SPI_ERROR_OVR);
-        MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_SPI_ERROR_FRE);
-        MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_SPI_ERROR_DMA);
-        MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_SPI_ERROR_FLAG);
+
+        // Check error and halde it.
+        if (peripheral_->ErrorCode & HAL_SPI_ERROR_CRC) {
+            MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "HAL_SPI_ERROR_CRC");
+            // This happens only in the CRC mode
+            interrupt_status_ = murasaki::kspisModeCRC;
+            // abort the processing
+            sync_->Release();
+        }
+        else if (peripheral_->ErrorCode & HAL_SPI_ERROR_OVR) {
+            MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "HAL_SPI_ERROR_OVR");
+            // This interrupt happen when the DMA is too slow to handle the received data.
+            interrupt_status_ = murasaki::kspisOverflow;
+            // abort the processing
+            sync_->Release();
+        }
+        else if (peripheral_->ErrorCode & HAL_SPI_ERROR_FRE) {
+            MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "HAL_SPI_ERROR_FRE");
+            // This interrupt is the frame error of the the TI frame mode
+            interrupt_status_ = murasaki::kspisFrameError;
+            // abort the processing
+            sync_->Release();
+        }
+        else if (peripheral_->ErrorCode & HAL_SPI_ERROR_DMA) {
+            MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "HAL_SPI_ERROR_DMA");
+            // This interrupt emans something happen in DMA unit
+            interrupt_status_ = murasaki::kspisDMA;
+            // abort the processing
+            sync_->Release();
+        }
+        else if (peripheral_->ErrorCode & HAL_SPI_ERROR_FLAG) {
+            MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "HAL_SPI_ERROR_FLAG");
+            // This interrupt emans something is recorded as error flag.
+            interrupt_status_ = murasaki::kspisErrorFlag;
+            // abort the processing
+            sync_->Release();
+        }
 #ifdef HAL_SPI_ERROR_ABORT
-        MURASAKI_PRINT_ERROR(peripheral_->ErrorCode & HAL_SPI_ERROR_ABORT);
+        else if (peripheral_->ErrorCode & HAL_SPI_ERROR_ABORT) {
+            MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "HAL_SPI_ERROR_ABORT");
+            // This interrupt happen when program causes problem during abort process
+            // No way to recover.
+            interrupt_status_ = murasaki::kspisAbort;
+            // abort the processing
+            sync_->Release();
+        }
 #endif
+        else
+        {
+            MURASAKI_SYSLOG(kfaSpiMaster, kseWarning, "Unknown error interrupt")
+        }
         SPIM_SYSLOG("Return");
         return true;    // report the ptr matched
     }

--- a/stm32_development/murasaki/murasaki/spimaster.hpp
+++ b/stm32_development/murasaki/murasaki/spimaster.hpp
@@ -57,6 +57,13 @@ namespace murasaki {
  *
  * Both methods can be called from only the task context. If these are called in the ISR
  * context, the result is unknown.
+ *
+ * Note : The behavior of when the timeout happen is not tested. Actually, it should not happen
+ * because DMA is taken in SPI transmission. Murasaki stpos internal DMA, interrupt and SPI processing
+ * internally then, return.
+ *
+ * Other error will cause the re-initializing of the SPI master. Murasaki doesn't support
+ * any of CRC detection, TI frame mode or Multi-master SPI.
  * @ingroup MURASAKI_GROUP
  */
 class SpiMaster : public AbstractSpiMaster
@@ -83,7 +90,7 @@ class SpiMaster : public AbstractSpiMaster
      * from the spi_spec. And then, assert the chips elect through the spi_spec during the
      * data transfer.
      */
-    virtual bool TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier * spi_spec,
+    virtual SpiStatus TransmitAndReceive(murasaki::AbstractSpiSlaveSpecifier * spi_spec,
 			const uint8_t * tx_data,
             uint8_t * rx_data, unsigned int size,
 			murasaki::WaitMilliSeconds timeout_ms = murasaki::kwmsIndefinitely);
@@ -116,6 +123,8 @@ class SpiMaster : public AbstractSpiMaster
     SPI_HandleTypeDef * const peripheral_;        // SPI peripheral handler.
     Synchronizer * const sync_;          // sync between task and interrupt
     CriticalSection * const critical_section_;    // protect memberfunction
+ private:
+    SpiStatus interrupt_status_;
 };
 
 } /* namespace murasaki */

--- a/stm32_development/nucleo-l152re-fujitsubo-test/nucleo-l152re-fujitsubo-test Debug.cfg	
+++ b/stm32_development/nucleo-l152re-fujitsubo-test/nucleo-l152re-fujitsubo-test Debug.cfg	
@@ -10,7 +10,6 @@ set WORKAREASIZE 0x8000
 transport select "hla_swd"
 
 set CHIPNAME STM32L152RETx
-set BOARDNAME NUCLEO-L152RE
 
 # Enable debug when in low power modes
 set ENABLE_LOW_POWER 1