new shared ring buffer

container/RingBufferBase.h

@@ -7,29 +7,23 @@
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(uint32_t startAddress, const size_t size, bool overwriteOld) :
+	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
 			start(startAddress), write(startAddress), size(size),
 			overwriteOld(overwriteOld) {
 		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
 			read[count] = startAddress;
 		}
 	}
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (availableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
+
+	virtual ~RingBufferBase() {}
+
+	bool isFull(uint8_t n = 0) {
+		return (availableWriteSpace(n) == 0);
 	}
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount || overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
+	bool isEmpty(uint8_t n = 0) {
+		return (availableReadData(n) == 0);
 	}
+
 	uint32_t availableReadData(uint8_t n = 0) const {
 		return ((write + size) - read[n]) % size;
 	}
@@ -37,54 +31,55 @@ public:
 		//One less to avoid ambiguous full/empty problem.
 		return (((read[n] + size) - write - 1) % size);
 	}
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(n) == 0);
-	}
-	virtual ~RingBufferBase() {
 
-	}
 	uint32_t getRead(uint8_t n = 0) const {
 		return read[n];
 	}
+
 	void setRead(uint32_t read, uint8_t n = 0) {
 		if (read >= start && read < (start+size)) {
 			this->read[n] = read;
 		}
 	}
+
 	uint32_t getWrite() const {
 		return write;
 	}
+
 	void setWrite(uint32_t write) {
 		this->write = write;
 	}
+
 	void clear() {
 		write = start;
 		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
 			read[count] = start;
 		}
 	}
-	uint32_t writeTillWrap() {
+
+	size_t writeTillWrap() {
 		return (start + size) - write;
 	}
-	uint32_t readTillWrap(uint8_t n = 0) {
+
+	size_t readTillWrap(uint8_t n = 0) {
 		return (start + size) - read[n];
 	}
-	uint32_t getStart() const {
+
+	size_t getStart() const {
 		return start;
 	}
+
 	bool overwritesOld() const {
 		return overwriteOld;
 	}
-	uint32_t maxSize() const {
+
+	size_t maxSize() const {
 		return size - 1;
 	}
 protected:
-	const uint32_t start;
-	uint32_t write;
-	uint32_t read[N_READ_PTRS];
+	const size_t start;
+	size_t write;
+	size_t read[N_READ_PTRS];
 	const size_t size;
 	const bool overwriteOld;
 	void incrementWrite(uint32_t amount) {
@@ -93,6 +88,24 @@ protected:
 	void incrementRead(uint32_t amount, uint8_t n = 0) {
 		read[n] = ((read[n] + amount - start) % size) + start;
 	}
+
+	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+		if (availableReadData(n) >= amount) {
+			incrementRead(amount, n);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+	ReturnValue_t writeData(uint32_t amount) {
+		if (availableWriteSpace() >= amount or overwriteOld) {
+			incrementWrite(amount);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
 };
 
 #endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */

container/SharedRingBuffer.cpp

@@ -0,0 +1,32 @@
+#include <framework/container/SharedRingBuffer.h>
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+
+SharedRingBuffer::SharedRingBuffer(const size_t size, bool overwriteOld):
+		SimpleRingBuffer(size, overwriteOld) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+SharedRingBuffer::SharedRingBuffer(uint8_t *buffer, const size_t size,
+		bool overwriteOld): SimpleRingBuffer(buffer, size, overwriteOld) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
+		size_t amount, dur_millis_t timeout) {
+	MutexHelper(mutex, timeout);
+	return writeData(data,amount);
+}
+
+ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
+		dur_millis_t timeout, bool incrementReadPtr, bool readRemaining,
+		size_t *trueAmount) {
+	MutexHelper(mutex, timeout);
+	return readData(data,amount, incrementReadPtr, readRemaining, trueAmount);
+}
+
+ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
+		bool deleteRemaining, size_t *trueAmount, dur_millis_t timeout) {
+	MutexHelper(mutex, timeout);
+	return deleteData(amount, deleteRemaining, trueAmount);
+}

container/SharedRingBuffer.h

@@ -0,0 +1,42 @@
+#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#include <framework/container/SimpleRingBuffer.h>
+#include <framework/ipc/MutexIF.h>
+#include <framework/timemanager/Clock.h>
+
+class SharedRingBuffer: public SimpleRingBuffer {
+public:
+	/**
+	 * This constructor allocates a new internal buffer with the supplied size.
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(const size_t size, bool overwriteOld);
+
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
+
+	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount,
+			dur_millis_t timeout = 10);
+	ReturnValue_t readDataProtected(uint8_t *data, size_t amount,
+			dur_millis_t timeout = 10, bool incrementReadPtr = false,
+			bool readRemaining = false, size_t *trueAmount = nullptr);
+	ReturnValue_t deleteDataProtected(size_t amount,
+			bool deleteRemaining = false, size_t* trueAmount = nullptr,
+			dur_millis_t timeout = 10);
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */

container/SimpleRingBuffer.cpp

@@ -16,12 +16,14 @@ SimpleRingBuffer::~SimpleRingBuffer() {
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		uint32_t amount) {
+		size_t amount) {
 	if (availableWriteSpace() >= amount or overwriteOld) {
-		uint32_t amountTillWrap = writeTillWrap();
+		size_t amountTillWrap = writeTillWrap();
 		if (amountTillWrap >= amount) {
+			// remaining size in buffer is sufficient to fit full amount.
 			memcpy(&buffer[write], data, amount);
-		} else {
+		}
+		else {
 			memcpy(&buffer[write], data, amountTillWrap);
 			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
 		}
@@ -32,12 +34,13 @@ ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 	}
 }
 
-ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
-		bool readRemaining, uint32_t* trueAmount) {
-	uint32_t availableData = availableReadData(READ_PTR);
-	uint32_t amountTillWrap = readTillWrap(READ_PTR);
+ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
+		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+	size_t availableData = availableReadData(READ_PTR);
+	size_t amountTillWrap = readTillWrap(READ_PTR);
 	if (availableData < amount) {
 		if (readRemaining) {
+			// more data available than amount specified.
 			amount = availableData;
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
@@ -52,12 +55,16 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
 		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
 		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
 	}
+
+	if(incrementReadPtr) {
+		deleteData(amount, readRemaining);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
-		bool deleteRemaining, uint32_t* trueAmount) {
-	uint32_t availableData = availableReadData(READ_PTR);
+ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
+		bool deleteRemaining, size_t* trueAmount) {
+	size_t availableData = availableReadData(READ_PTR);
 	if (availableData < amount) {
 		if (deleteRemaining) {
 			amount = availableData;

container/SimpleRingBuffer.h

@@ -18,6 +18,8 @@ public:
      * This constructor allocates a new internal buffer with the supplied size.
      * @param size
      * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
      */
 	SimpleRingBuffer(const size_t size, bool overwriteOld);
 	/**
@@ -25,41 +27,59 @@ public:
 	 * @param buffer
 	 * @param size
 	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
 	 */
 	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
 
 	virtual ~SimpleRingBuffer();
 
 	/**
-	 * Write to circular buffer and increment write pointer by amount
+	 * Write to circular buffer and increment write pointer by amount.
 	 * @param data
 	 * @param amount
-	 * @return
+	 * @return -@c RETURN_OK if write operation was successfull
+	 * -@c RETURN_FAILED if
 	 */
-	ReturnValue_t writeData(const uint8_t* data, uint32_t amount);
+	ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
 	/**
-	 * Read from circular buffer at read pointer
+	 * Read from circular buffer at read pointer.
 	 * @param data
 	 * @param amount
+	 * @param incrementReadPtr
+	 * If this is set to true, the read pointer will be incremented.
+	 * If readRemaining is set to true, the read pointer will be incremented
+	 * accordingly.
 	 * @param readRemaining
-	 * @param trueAmount
+	 * If this is set to true, the data will be read even if the amount
+	 * specified exceeds the read data available.
+	 * @param trueAmount [out]
+	 * If readRemaining was set to true, the true amount read will be assigned
+	 * to the passed value.
 	 * @return
+	 * - @c RETURN_OK if data was read successfully
+	 * - @c RETURN_FAILED if not enough data was available and readRemaining
+	 *      was set to false.
 	 */
-	ReturnValue_t readData(uint8_t* data, uint32_t amount,
-	        bool readRemaining = false, uint32_t* trueAmount = nullptr);
+	ReturnValue_t readData(uint8_t* data, size_t amount,
+			bool incrementReadPtr = false, bool readRemaining = false,
+			size_t* trueAmount = nullptr);
 
 	/**
-	 * Delete data starting by incrementing read pointer
+	 * Delete data by incrementing read pointer.
 	 * @param amount
 	 * @param deleteRemaining
-	 * @param trueAmount
+	 * If the amount specified is larger than the remaing size to read and this
+	 * is set to true, the remaining amount will be deleted as well
+	 * @param trueAmount [out]
+	 * If deleteRemaining was set to true, the amount deleted will be assigned
+	 * to the passed value.
 	 * @return
 	 */
-	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false,
-	        uint32_t* trueAmount = nullptr);
+	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+	        size_t* trueAmount = nullptr);
 private:
-//	static const uint8_t TEMP_READ_PTR = 1;
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
 };