Commit: 563c3277e232a9ac0a0b6fa31101c9913f2d7b42 - shared_foo_backup (git)

shared_fooの不要ディレクトリ削除前のもの

Commit MetaInfo

• Revision: 563c3277e232a9ac0a0b6fa31101c9913f2d7b42 (tree)
• Time: 2018-03-03 15:55:47
• Author: takemasa <suikan@user...>
• Commiter: takemasa

Log Message

Removed ifdef

Change Summary

• modified: stm32_development/murasaki/murasaki/debugger.cpp
• modified: stm32_development/murasaki/murasaki/debugger.hpp

Incremental Difference

--- a/stm32_development/murasaki/murasaki/debugger.cpp
+++ b/stm32_development/murasaki/murasaki/debugger.cpp
@@ -22,31 +22,13 @@ Debugger::Debugger(AbstractLogger * logger)
     // initialize internal variable;
     MURASAKI_ASSERT(logger != nullptr)
 
-    auto_history_enabled = false;
-    auto_history_task_ = nullptr;
-
-#ifdef OLDIMPLEMENTATION
-    logger_ = logger;
-    sem_notify_new_data_ = ::xSemaphoreCreateBinary();      // create semaphore as "empty" state
-    MURASAKI_ASSERT(sem_notify_new_data_);
-
-    // set the circular buffer empty.
-    head_ = 0;
-    tail_ = 0;
-
-    for (unsigned int i = 0; i < sizeof(buffer_); i++)
-        buffer_[i] = ' ';
-    // start the debug task
-    BaseType_t task_result = ::xTaskCreate(
-                  Debugger::LaunchTxTask,                      // task entity;
-                  "DebugTask",                              // name of task
-                  PLATFORM_CONFIG_DEBUG_TASK_STACK_SIZE,    // stack depth
-                  this,                                     // parameter to task
-                  PLATFORM_CONFIG_DEBUG_TASK_PRIORITY,      // execusion priority of task
-                  &tx_task_                                 // receive task handle
-                  );
-    MURASAKI_ASSERT(task_result != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY);
-#else
+
+    helpers_.fifo = nullptr;
+    tx_task_ = nullptr;
+
+    auto_reprint_enable_ = false;
+    auto_reprint_task = nullptr;
+
     helpers_.fifo = new murasaki::DebuggerFifo(PLATFORM_CONFIG_DEBUG_BUFFER_SIZE);
     helpers_.logger = logger;
 
@@ -59,66 +41,25 @@ Debugger::Debugger(AbstractLogger * logger)
 
     tx_task_->Start();
 
-#endif
 }
 
 Debugger::~Debugger()
 {
-#ifdef OLDIMPLEMENTATION
     // Delete task;
     if (tx_task_ != nullptr)
-        ::vTaskDelete(tx_task_);
+        delete tx_task_;
 
     // Delete task;
-    if (auto_history_task_ != nullptr)
-        ::vTaskDelete(auto_history_task_);
+    if (auto_reprint_task != nullptr)
+        delete auto_reprint_task;
 
-    // Delete semaphore.
-    if (sem_notify_new_data_ != nullptr)
-        ::vSemaphoreDelete( sem_notify_new_data_);
-#else
-#endif
+    // Delete FIFO
+    if (helpers_.fifo != nullptr)
+        delete helpers_.fifo;
 }
 
 void Debugger::printf(const char * fmt, ...)
 {
-#ifdef OLDIMPLEMENTATION
-    // obtain variable parameter list
-    va_list argp;
-
-    MURASAKI_ASSERT(nullptr != fmt);  // nullptr check. Perhaps, overkill.
-
-    portDISABLE_INTERRUPTS();   // ARM dependent API. OK to use in task and ISR.
-    {
-#if 0
-        // Test the remains of task stack in byte.
-        // To use the uxTaskGetStackHighWaterMark(), Add following to the
-        // FreeRTOSConfig.h
-        // #define INCLUDE_uxTaskGetStackHighWaterMark 1
-
-        ::snprintf((char *) line_,
-                    sizeof(line_) - 1,
-                    "stack remains : %8d bytes. ",
-                    (int) uxTaskGetStackHighWaterMark(tx_task_));
-        AppendToBuffer();
-#endif
-        ::va_start(argp, fmt);
-        // convert the number with formt string to the line string.
-        // The string length have to be N - 1. Where N is the length of the destination variable.
-        ::vsnprintf((char *) line_, sizeof(line_) - 1, fmt, argp);
-
-        ::va_end(argp);
-        // Append the line to the buffer to be sent.
-        AppendToBuffer();
-    }
-    portENABLE_INTERRUPTS();
-
-    // Notify to the consumer task, the new data has come.
-    if (isTaskContext())    // Are we in the task context?
-        ::xSemaphoreGive(sem_notify_new_data_);               // if yes
-    else
-        ::xSemaphoreGiveFromISR(sem_notify_new_data_, nullptr);  // if no.
-#else
         // obtain variable parameter list
         va_list argp;
 
@@ -152,56 +93,16 @@ void Debugger::printf(const char * fmt, ...)
 
         // Notify to the consumer task, the new data has come.
     helpers_.fifo->NotifyData();
-#endif
 
 }
 
 char Debugger::GetchFromTask()
 {
     MURASAKI_ASSERT(isTaskContext());
-#ifdef OLDIMPLEMENTATION
-    return logger_->getCharacter();  // receive successfuly.
-#else
+
     return helpers_.logger->getCharacter();
-#endif
 }
 
-// Assumes this is called only in the critical section.
-void Debugger::AppendToBuffer()
-{
-#ifdef OLDIMPLEMENTATION
-    unsigned int avairable;
-
-    // check the avairable area size. Data is append to the head
-    if (head_ > tail_)  // there is no wrap around
-        avairable = sizeof(buffer_) - (head_ - tail_);
-    else if (tail_ > head_)
-        avairable = tail_ - head_;
-    else
-        avairable = sizeof(buffer_);
-
-    // If we fill up buffer entirely, we can not distinguish full and empty from the
-    // comparing tail_ and head_.
-    // This can be fixed if we add new variable "length", but it get complex.
-    // To save this problem, we clip the vacant size by buffsersize-1.
-    if (avairable > 0)
-        avairable--;
-
-    // clip the line size by available room in the buffer.
-    int line_length = std::min(::strlen((char *) line_), avairable);
-
-    // Now, we can copy from line to buffer.
-    for (int i = 0; i < line_length; i++) {
-        // newest data is appended to the point of head_
-        buffer_[head_] = line_[i];
-        head_++;
-
-        // wrap around the head index;
-        if (head_ >= sizeof(buffer_))
-            head_ = 0;
-    }  // end for loop.
-#endif
-}
 
 
 /*
@@ -210,46 +111,15 @@ void Debugger::AppendToBuffer()
  */
 void Debugger::RePrint()
 {
-#ifdef OLDIMPLEMENTATION
-    MURASAKI_ASSERT(isTaskContext());
-
-    taskENTER_CRITICAL();
-    {
-        // Mark the all old data as "not sent"
-        // By setting the circular buffer length maximumn.
-        tail_ = head_ + 1;
-        // wrap around the tail_index;
-        if (tail_ >= sizeof(buffer_))
-            tail_ = 0;
-    }
-    taskEXIT_CRITICAL();
-
-    // tell there is data
-    ::xSemaphoreGive(sem_notify_new_data_);
-#else
     helpers_.fifo->ReWind();
-#endif
 }
 
 void Debugger::AutoHistory()
 {
     MURASAKI_ASSERT(isTaskContext());
     // protecting from double task creation
-    if (auto_history_enabled)
+    if (auto_reprint_enable_)
         return;
-#ifdef OLDIMPLEMENTATION
-
-    // start the debug task
-    BaseType_t task_result = ::xTaskCreate(Debugger::LaunchAutoHistoryTask,             // task entity;
-                                           "AutoHistoryTask",                        // name of task
-                                           PLATFORM_CONFIG_DEBUG_TASK_STACK_SIZE,    // stack depth
-                                           this,                                     // parameter to task
-                                           PLATFORM_CONFIG_DEBUG_TASK_PRIORITY,      // execusion priority of task
-                                           &auto_history_task_                       // receive task handle
-                                           );
-    MURASAKI_ASSERT(task_result != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY);
-
-#else
     auto_reprint_task = new murasaki::DebuggerAutoRePrintTask("DebugTask",                              // name of task
                                                               PLATFORM_CONFIG_DEBUG_TASK_STACK_SIZE,      // stack depth
                                                               PLATFORM_CONFIG_DEBUG_TASK_PRIORITY,  // execusion priority of task
@@ -259,94 +129,8 @@ void Debugger::AutoHistory()
 
     auto_reprint_task->Start();
 
-#endif
-    auto_history_enabled = true;
-}
-
-void Debugger::LaunchAutoHistoryTask(void* this_pointer)
-{
-    MURASAKI_ASSERT(nullptr != this_pointer);
-
-    // This is "interface class method" to allow to use a private method as task.
-    // The caller passes the "this" pointer as parameter.
-    // The caller is always "Debug" task.
-    // The AutoHistoryTask() is private and task body.
-    static_cast<Debugger *>(this_pointer)->AutoHistoryTask();
-
-}
-
-void Debugger::AutoHistoryTask()
-{
-    MURASAKI_ASSERT(isTaskContext());
-    // Task body. Never return.
-    while (true) {
-        // wait for the arraival of inpu
-        GetchFromTask();
-        // flush old data.
-        RePrint();
-    }  // end of while loop.
-
+    auto_reprint_enable_ = true;
 }
 
 
-void Debugger::LaunchTxTask(void * this_pointer)
-{
-    MURASAKI_ASSERT(nullptr != this_pointer);
-    // This is "interface class method" to allow to use a private method as task.
-    // The caller passes the "this" pointer as parameter.
-    // The caller is always "Debug" task.
-    // The txTask() is private and task body.
-    static_cast<Debugger *>(this_pointer)->TxTask();
-}
-
-#define BLOCK_SIZE 50
-void Debugger::TxTask()
-{
-#ifdef OLDIMPLEMENTATION
-    unsigned int copy_size = 0;
-    uint8_t block[BLOCK_SIZE];
-
-    // Task body. Never return.
-    while (true) {
-        // To avoid race condition, Take a snapshot of the head_ and tail_ pointer.
-        // head_ could be modified during this task is running but no problem.
-        taskENTER_CRITICAL();
-        {
-            // check whether the data area is wrapped araound at the end of buffer. Note : Data is added to the head.
-            if (head_ > tail_) {    // not wrapped around
-                // transmit at largest one block
-                copy_size = std::min(sizeof(block), head_ - tail_);
-                ::memcpy(block, &buffer_[tail_], copy_size);
-                // update tail. Wrap around never occur.
-                tail_ += copy_size;
-            }
-            else if (tail_ > head_) {    // wrapped arraound
-                // transmit at largest one block
-                copy_size = std::min(sizeof(block), sizeof(buffer_) - tail_);
-                ::memcpy(block, &buffer_[tail_], copy_size);
-                // update tail.
-                tail_ += copy_size;
-
-                // if tail_ reaches the end, wrap around.
-                if (tail_ >= sizeof(buffer_))
-                    tail_ = 0;
-            }
-            else
-                // head_ == tail_ . Do nothing.
-                copy_size = 0;
-        }
-        taskEXIT_CRITICAL();
-
-        if (copy_size != 0)  // if copied
-            logger_->putMessage((char *) block, copy_size);
-        else
-            // if head_ == tail_
-            // Wait for the arrival of the new data because buffer empty.
-            // To avoid race condition, we use time out.
-            ::xSemaphoreTake(sem_notify_new_data_, 1000 / portTICK_PERIOD_MS );
-
-    }  // end of while loop.
-#endif
-}
-
 } /* namespace platform */

--- a/stm32_development/murasaki/murasaki/debugger.hpp
+++ b/stm32_development/murasaki/murasaki/debugger.hpp
@@ -18,14 +18,9 @@
 #include "murasaki_config.hpp"
 #include "abstractlogger.hpp"
 
-//#define OLDIMPLEMENTATION
-
-#ifdef OLDIMPLEMENTATION
-#else
 #include "debuggerfifo.hpp"
 #include "debuggertxtask.hpp"
 #include "debuggerautoreprinttask.hpp"
-#endif
 
 namespace murasaki {
 
@@ -118,114 +113,33 @@ class Debugger
      */
     void AutoHistory();
  protected:
-#ifdef OLDIMPLEMENTATION
-    /**
-     * \brief A pointer to the logger class.
-     */
-    AbstractLogger* logger_;
-    /**
-     * @brief For protecting from the double creating of the internal task.
-     */
-    /**
-     * \brief Transmission notification semaphore.
-     * \details
-     * This semaphoere is initialized as binary semaphore, and applied as data avairable
-     * notification. Whenever the printf() method added new data to the buffer_, a nothification
-     * is given through this semaphore.
-     */
-    /**
-     * \brief Handle to the transmission control task.
-     */
-    TaskHandle_t tx_task_;
-    SemaphoreHandle_t sem_notify_new_data_;
-    /**
-     * \brief transmission data circular buffer.
-     */
-    char buffer_[PLATFORM_CONFIG_DEBUG_BUFFER_SIZE];
-#else
     murasaki::LoggingHelpers helpers_;
     /**
      * \brief Handle to the transmission control task.
      */
     murasaki::DebuggerTxTask * tx_task_;
 
-    murasaki::DebuggerAutoRePrintTask * auto_reprint_task;
-#endif
-    bool auto_history_enabled;
-    /**
-     * \brief temporal data buffer to store the formatted string.
-     */
-    char line_[PLATFORM_CONFIG_DEBUG_LINE_SIZE];
     /**
      * @brief Handle to the auto history task.
      */
-    TaskHandle_t auto_history_task_;
-    /**
-     * \brief Index of the "next of " newest data in the buffer.
-     * \details
-     * Pointing the location which the next new data will be stored.
-     *
-     * In case of the empty buffer, this index is same with the tail_.
-     */
-    volatile unsigned int head_;
-    /**
-     * \brief Index of the oldest data in the buffer.
-     * \details
-     * Pointing the location where the next data to be read.
-     *
-     * In case of the empty buffer, this index is same with the head_.
-     */
-    volatile unsigned int tail_;
+    murasaki::DebuggerAutoRePrintTask * auto_reprint_task;
 
     /**
-     * \brief Wrapper of the txTask.
-     * \param this_pointer The this pointer of the caller object have to be passed.
-     * \details
-     *
-     * Wrapper of the txTask() method. The txTask() is the private method. Then, it is
-     * unable to pass to the FreeRTOS API, while we have to pass that to run a task.
-     *
-     * To solve this problem, this wrapper method is declared as class method. The
-     * this pointer have to be passed to the this_pointer parameter.
-     *
-     * This method is dedicated to use in the constructor. User doesn't need to touch
+     * @brief For protecting from double enabled.
      */
-    static void LaunchTxTask(void * this_pointer);
-
-    /*
-     *
-     * Wrapper of the AutoHistoryTask
-     */
-    static void LaunchAutoHistoryTask(void * this_pointer);
+    bool auto_reprint_enable_;
 
     /**
-     * \brief Task body
-     * \details
-     * The task bordy of the transmission task. This method is called from launchTxTas(), and
-     * never returns.
-     *
-     * This task test the head_ and tail_ and if the length is not one, try to transmit
-     * the data inside buffer, throuth the uart.
+     * @brief as receiver for the snprintf()
+     * @details
+     * This variable can be local variable of the printf() member function.
+     * In thiss case, the implementation of the printf() is much easier.
+     * In the other hand, each task must has enough depth on its task stack.
      *
-     * If there is no data, this task wait for the new data to transmit by sem_notify_new_data_
-     * semaphore. In parallel to this waiting, it polls the data buffer length by time out
-     * of semaphore. This polling is essential, because perfect exclusive access and synchronization
-     * is expensive.
-     */
-    void TxTask();
-
-    /*
-     * Task to watch the receive character and trigger the history.
+     * Probably, having bigger task for each task doesn't pay, and it may cuase stack overflow bug
+     * at the debug or assertion. This is not preferable.
      */
-    void AutoHistoryTask();
-    /**
-     * \brief Copy the data in line_ to the buffer_
-     * \details
-     * This helper method copies the data from line_ into the buffer. And then, udpate the
-     * head_ index. In case the vacant area is not enough to copy entire data in line_,
-     * This method transfer as long as possible, and returns.
-     */
-    void AppendToBuffer();
+    char line_[PLATFORM_CONFIG_DEBUG_LINE_SIZE];
 
 };