Commit: f85ea7093d3d70ee3e9b6e57f24536a7ee5a7fd6 - shared_foo (git)

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

Commit MetaInfo

• Revision: f85ea7093d3d70ee3e9b6e57f24536a7ee5a7fd6 (tree)
• Time: 2018-02-28 07:29:39
• Author: takemasa <suikan@user...>
• Commiter: takemasa

Log Message

Implemented BaseFIFO

Change Summary

• modified: stm32_development/murasaki/NUCLEO-F746ZG.xml
• modified: stm32_development/murasaki/murasaki/basefifo.cpp
• modified: stm32_development/murasaki/murasaki/basefifo.hpp

Incremental Difference

--- a/stm32_development/murasaki/NUCLEO-F746ZG.xml
+++ b/stm32_development/murasaki/NUCLEO-F746ZG.xml
@@ -12,8 +12,8 @@
 <targetDefinitions>
   <board id="nucleo-f746zg">
     <name>NUCLEO-F746ZG</name>
-    <dbgIF>SWD</dbgIF>
     <dbgIF>JTAG</dbgIF>
+    <dbgIF>SWD</dbgIF>
     <dbgDEV>ST-Link</dbgDEV>
     <mcuId>stm32f746zgtx</mcuId>
   </board>

--- a/stm32_development/murasaki/murasaki/basefifo.cpp
+++ b/stm32_development/murasaki/murasaki/basefifo.cpp
@@ -6,18 +6,104 @@
  */
 
 #include <basefifo.hpp>
+#include <murasaki_assert.hpp>
+#include <algorithm>
+#include <string.h>
 
 namespace murasaki {
 
-BaseFifo::BaseFifo()
+BaseFifo::BaseFifo(unsigned int buffer_size):
+          size_of_buffer_(buffer_size),
+          buffer_(new uint8_t[size_of_buffer_])
 {
-    // TODO Auto-generated constructor stub
+    MURASAKI_ASSERT(size_of_buffer_ != 0);        // very explicit check
+    MURASAKI_ASSERT(buffer_ != nullptr);
 
 }
 
+
 BaseFifo::~BaseFifo()
 {
-    // TODO Auto-generated destructor stub
+    if (buffer_ != nullptr)
+        delete[] buffer_;
+}
+
+unsigned int BaseFifo::Put(uint8_t const data[], unsigned int size)
+{
+    unsigned int avairable;
+
+    // check the avairable area size. Data is append to the head
+    if (head_ > tail_)  // there is no wrap around
+        avairable = size_of_buffer_ - (head_ - tail_);
+    else if (tail_ > head_)
+        avairable = tail_ - head_;
+    else
+        avairable = size_of_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.
+    unsigned int copy_size = std::min(size, avairable);
+
+    // Now, we can copy from line to buffer.
+    for (unsigned int i = 0; i < copy_size; i++) {
+        // newest data is appended to the point of head_
+        buffer_[head_] = data[i];
+        head_++;
+
+        // wrap around the head index;
+        if (head_ >= size_of_buffer_)
+            head_ = 0;
+    }  // end for loop.
+
+    return copy_size;
+
+}
+
+unsigned int BaseFifo::Get(uint8_t data[], unsigned int size)
+{
+    unsigned int copy_size = 0;
+
+    // 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.
+    // check whether the data area is wrapped araound at the end of buffer. Note : Data is added to the head.
+
+    if (head_ == tail_)
+        copy_size = 0;  // nothing to copy
+    else {
+        if (head_ > tail_)
+            copy_size = std::min(size, head_ - tail_);
+        else
+            // tail_ > head_
+            copy_size = std::min(size, size_of_buffer_ - tail_);    // stop once, at the end of buffer.
+
+        // copy data to output buffer
+        ::memcpy(data, &buffer_[tail_], copy_size);
+        // update tail.
+        tail_ += copy_size;
+
+        // if tail_ reaches the end, wrap around.
+        if (tail_ >= size_of_buffer_)
+            tail_ = 0;
+    }
+
+
+    return copy_size;
+}
+
+void BaseFifo::ReWind()
+{
+    // by setting tail as head+1, the entire buffer is marked as "not sent"
+    tail_ = head_ + 1;
+
+    // wrap arround;
+    if (tail_ >= size_of_buffer_)
+        tail_ = 0;
 }
 
 } /* namespace murasaki */

--- a/stm32_development/murasaki/murasaki/basefifo.hpp
+++ b/stm32_development/murasaki/murasaki/basefifo.hpp
@@ -1,28 +1,81 @@
-/*
- * basefifo.hpp
+/**
+ * @file basefifo.hpp
  *
- *  Created on: 2018/02/26
- *      Author: takemasa
+ * @date 2018/02/26
+ * @author takemasa
  */
 
 #ifndef BASEFIFO_HPP_
 #define BASEFIFO_HPP_
 
 #include <ctype.h>
+#include <cinttypes>
 
 namespace murasaki {
 
+/**
+ * @brief Basic FIFO without thread safe.
+ * @details
+ * Foundemental FIFO. No blocking , not thread safe.
+ *
+ * The Put member function returns with "copied" data count.
+ * If the internal buffer is full, it returns without copy data.
+ *
+ * The Get member funciton returns with "copied" data count and data.
+ * If the internal buffer is empty, it returns without copy data.
+ *
+ */
 class BaseFifo
 {
  public:
+    BaseFifo() = delete;
+    /**
+     * @brief Create an internal buffer
+     * @param buffer_size Size of the internal buffer to be allocated [byte]
+     * @details
+     * Allocate the internal buffer with given buffer_size.
+     */
     BaseFifo(unsigned int buffer_size);
+    /**
+     * @breif Delete an internal buffer
+     */
     virtual ~BaseFifo();
+    /**
+     * @brief Put the data into the internal buffer.
+     * @param data Data to be copied to the internal buffer
+     * @param size Data count to be copied
+     * @return The count of copied data. 0, if the internal buffer is full.
+     */
     unsigned int Put(uint8_t const data[], unsigned int size);
+    /**
+     * @brief Get the data from the internal buffer.
+     * @param data Data buffer to receive from the internal buffer
+     * @param size Size of the data parameter.
+     * @return The count of copied data. 0, if the internal buffer is empty
+     */
     unsigned int Get(uint8_t data[], unsigned int size);
+    /*
+     * @brief Mark all the data inside the internal buffer as "not sent".
+     */
     void ReWind();
  private:
+    /**
+     * @brief The index of where next data will be written.
+     */
     unsigned int head_ = 0;
+    /**
+     * @brief The index of where the next data will be read.
+     * @details
+     * If head_ = tail_, buffer is empty.
+     */
     unsigned int tail_ = 0;
+    /**
+     * @brief Size of the internal buffer [byte]
+     */
+    unsigned int const size_of_buffer_;
+    /**
+     * @brief The internal buffer. Allocated by constructor.
+     */
     uint8_t * const buffer_;
 
 };