Update CircuitOS library to v1.5.0

Author: filipbudisa

libraries/CircuitOS/Setup.hpp

@@ -15,6 +15,9 @@
  * The library has better performance on higher-res screens (320x240 and above). */
 // #define CIRCUITOS_LOVYANGFX
 
+/** Zoom factor for the display buffer, 2 means every pixel in the buffer equates to 4 pixels on-screen. */
+// #define CIRCUITOS_LOVYANGFX_ZOOM 1
+
 /** Whether NVS (non-volatile storage) is present in the core. Enables NVS variant of Settings */
 // #define CIRCUITOS_NVS
 

libraries/CircuitOS/library.properties

@@ -1,5 +1,5 @@
 name=CircuitOS
-version=1.4.0
+version=1.5.0
 author=CircuitMess
 maintainer=Filip Budiša <[email protected]>
 sentence=Circuit OS is our custom-made operating system built on top of FreeRTOS.

libraries/CircuitOS/src/Buffer/RingBuffer.cpp

@@ -58,6 +58,13 @@ size_t RingBuffer::write(uint8_t* source, size_t n){
 	return n;
 }
 
+size_t RingBuffer::skip(size_t n){
+	n = min(n, readAvailable());
+	if(n == 0) return 0;
+	beginning = (beginning + n) % size;
+	return n;
+}
+
 void RingBuffer::clear(){
 	beginning = end = 0;
 }

libraries/CircuitOS/src/Buffer/RingBuffer.h

@@ -14,6 +14,15 @@ class RingBuffer {
 	size_t read(uint8_t* destination, size_t n);
 	size_t write(uint8_t* source, size_t n);
 
+	template<typename T>
+	const T* peek(size_t offset = 0){
+		if(offset + sizeof(T) > readAvailable()) return nullptr;
+		offset = (beginning + offset) % size;
+		return (T*) (buffer + offset);
+	}
+
+	size_t skip(size_t n);
+
 	void clear();
 
 private:

libraries/CircuitOS/src/Display/Display.cpp

@@ -61,7 +61,11 @@ void Display::commit(){
 	}
 #ifdef CIRCUITOS_LOVYANGFX
 	tft.startWrite();
-	baseSprite->pushRotateZoom(161, 121, 0, 2, 2);
+#ifdef CIRCUITOS_LOVYANGFX_ZOOM
+	baseSprite->pushRotateZoom(width + 1, height + 1, 0, CIRCUITOS_LOVYANGFX_ZOOM, CIRCUITOS_LOVYANGFX_ZOOM);
+#else
+	baseSprite->push();
+#endif
 	tft.endWrite();
 #else
 	baseSprite->push();

libraries/CircuitOS/src/Display/LovyanGFX_setup.h

@@ -9,7 +9,7 @@
 namespace lgfx {
 class LGFX : public lgfx::LGFX_Device {
 
-	lgfx::Panel_ILI9341 _panel_instance;
+	lgfx::LOVYAN_PANEL _panel_instance;
 	lgfx::Bus_SPI _bus_instance;
 
 public:
@@ -21,8 +21,8 @@ class LGFX : public lgfx::LGFX_Device {
 
 			cfg.spi_host = VSPI_HOST;
 			cfg.spi_mode = 0;
-			cfg.freq_write = 60000000;
-			cfg.freq_read = 60000000;
+			cfg.freq_write = LOVYAN_FREQ;
+			cfg.freq_read = LOVYAN_FREQ;
 			cfg.spi_3wire = false;
 			cfg.use_lock = true;
 			cfg.dma_channel = 1;

libraries/CircuitOS/src/FS/RamFile.cpp

@@ -1,18 +1,18 @@
 #include "RamFile.h"
 
-RamFile::RamFile(uint8_t* data, size_t size) : data(data), dataSize(size){
+RamFile::RamFile(uint8_t* data, size_t size, bool readonly) : data(data), dataSize(size), readonly(readonly){
 
 }
 
 RamFile::~RamFile(){
 	RamFile::close();
 }
 
-fs::File RamFile::open(uint8_t* data, size_t size){
-	return File(std::make_shared<RamFile>(data, size));
+fs::File RamFile::open(uint8_t* data, size_t size, bool readonly){
+	return File(std::make_shared<RamFile>(data, size, readonly));
 }
 
-fs::File RamFile::open(fs::File file){
+fs::File RamFile::open(fs::File& file, bool readonly){
 	uint8_t* data;
 #ifdef CONFIG_SPIRAM_SUPPORT
 	data = static_cast<uint8_t*>(ps_malloc(file.size()));
@@ -23,7 +23,7 @@ fs::File RamFile::open(fs::File file){
 	file.seek(0);
 	file.readBytes(reinterpret_cast<char*>(data), file.size());
 
-	auto f = std::make_shared<RamFile>(data, file.size());
+	auto f = std::make_shared<RamFile>(data, file.size(), readonly);
 
 	String name = file.name();
 	char* fstr = static_cast<char*>(malloc(name.length() + 1));
@@ -35,17 +35,37 @@ fs::File RamFile::open(fs::File file){
 }
 
 size_t RamFile::write(uint8_t data){
+	if(readonly) return 0;
+
+	if(cursor == dataSize){
+		dataSize++;
+	}
+
 	this->data[cursor++] = data;
 	return 1;
 }
 
 size_t RamFile::write(const uint8_t* buf, size_t size){
+	if(readonly) return 0;
+	if(size == 0) return 0;
+
+	if(cursor + size > dataSize){
+		dataSize = size + cursor;
+#ifdef CONFIG_SPIRAM_SUPPORT
+		data = static_cast<uint8_t*>(ps_realloc(data, dataSize));
+#else
+		data = static_cast<uint8_t*>(realloc(data, dataSize));
+#endif
+	}
+
 	memcpy(data + cursor, buf, size);
 	cursor += size;
+
+	return size;
 }
 
 int RamFile::available(){
-	return cursor < dataSize;
+	return dataSize - cursor;
 }
 
 int RamFile::read(){
@@ -61,16 +81,12 @@ void RamFile::flush(){
 }
 
 bool RamFile::seek(uint32_t pos, fs::SeekMode mode){
-	switch(mode){
-		case fs::SeekSet:
-			cursor = pos;
-			break;
-		case fs::SeekEnd:
-			cursor = dataSize - pos - 1;
-			break;
-		case fs::SeekCur:
-			cursor += pos;
-			break;
+	if(mode == fs::SeekSet){
+		cursor = pos;
+	}else if(mode == fs::SeekEnd){
+		cursor = dataSize - pos;
+	}else if(mode == fs::SeekCur){
+		cursor += pos;
 	}
 }
 

libraries/CircuitOS/src/FS/RamFile.h

@@ -16,11 +16,11 @@ class RamFile : public fs::FileImpl {
 	void rewindDirectory() ;
 	operator bool() ;
 #endif
-	RamFile(uint8_t* data, size_t size);
+	RamFile(uint8_t* data, size_t size, bool readonly = true);
 	virtual ~RamFile();
 
-	static fs::File open(uint8_t* data, size_t size);
-	static fs::File open(fs::File file);
+	static fs::File open(uint8_t* data, size_t size, bool readonly = true);
+	static fs::File open(fs::File& file, bool readonly = true);
 
 	size_t write(const uint8_t* buf, size_t size) override;
 	size_t read(uint8_t* buf, size_t size) override;
@@ -51,6 +51,7 @@ class RamFile : public fs::FileImpl {
 	uint8_t* data = nullptr;
 	size_t dataSize;
 	size_t cursor = 0;
+	bool readonly;
 	const char* filename = nullptr;
 
 };

libraries/CircuitOS/src/Input/I2cExpander.cpp

@@ -14,13 +14,21 @@ I2cExpander::I2cExpander()
 I2cExpander::~I2cExpander()
 {
 }
-void I2cExpander::begin(uint8_t _address, uint8_t _sda, uint8_t _scl)
+bool I2cExpander::begin(uint8_t _address, uint8_t _sda, uint8_t _scl)
 {
 	address = _address;
 	Wire.begin(_sda, _scl);
+
+	Wire.beginTransmission(address);
+	if(Wire.endTransmission() != 0){
+		return false;
+	}
+
 	portWrite(0xFFFF);
 	_write(0x0000, INVERT_REG);
 	portConfig(0xFFFF);
+
+	return true;
 }
 void I2cExpander::_write(uint16_t _portData, uint8_t reg)
 {

libraries/CircuitOS/src/Input/I2cExpander.h

@@ -13,7 +13,7 @@ class I2cExpander
 public:
 	I2cExpander();
 	~I2cExpander();
-	void begin(uint8_t _address = 0x74, uint8_t _sda = 27, uint8_t _scl = 14);
+	bool begin(uint8_t _address = 0x74, uint8_t _sda = 27, uint8_t _scl = 14);
 	uint16_t portRead();
 	bool portRead(uint16_t& state);
 	void pinMode(uint8_t pin, uint8_t mode);

libraries/CircuitOS/src/Input/Input.cpp

@@ -64,6 +64,8 @@ void Input::btnPress(uint i){
 			}
 
 			for(auto listener : listeners){
+				if(mask.find(listener) != mask.end()) continue;
+
 				if(removedListeners.find(listener) != removedListeners.end()) continue;
 				listener->buttonPressed(buttons[i]);
 				if(removedListeners.find(listener) != removedListeners.end()) continue;
@@ -102,6 +104,8 @@ void Input::btnRelease(uint i){
 			btnHoldRepeatCounter[buttons[i]] = 0;
 
 			for(auto listener : listeners){
+				if(mask.find(listener) != mask.end()) continue;
+
 				if(removedListeners.find(listener) != removedListeners.end()) continue;
 				listener->buttonReleased(buttons[i]);
 				if(listener->holdTimes.find(buttons[i]) != listener->holdTimes.end()){
@@ -139,6 +143,8 @@ void Input::loop(uint _time){
 			}
 
 			for(auto listener : listeners){
+				if(mask.find(listener) != mask.end()) continue;
+
 				auto search = listener->holdTimes.find(buttons[i]);
 				if(search != listener->holdTimes.end() && holdTime >= search->second.time && !search->second.holdingOver){
 					listener->buttonHeld(buttons[i]);
@@ -185,6 +191,11 @@ uint32_t Input::getButtonHeldMillis(uint8_t pin){
 	return millis() - btnHoldStart[pin];
 }
 
+bool Input::getButtonState(uint8_t pin){
+	if(pin >= btnState.size()) return false;
+	return btnState[pin];
+}
+
 void Input::setAnyKeyCallback(void (* callback)(), bool returnAfterCallback){
 	anyKeyCallback = callback;
 	anyKeyCallbackReturn = returnAfterCallback;
@@ -205,11 +216,20 @@ void Input::addListener(InputListener* listener){
 	if(l != removedListeners.end()){
 		removedListeners.erase(l);
 	}
+
+	for(auto pair : listener->holdTimes){
+		pair.second.holdingOver = false;
+	}
+
+	for(auto pair : listener->holdAndRepeatTimes){
+		pair.second.repeatCounter = 0;
+	}
 }
 
 void Input::removeListener(InputListener* listener){
 	if(listeners.indexOf(listener) == -1 || removedListeners.find(listener) != removedListeners.end()) return;
 	removedListeners.insert(listener);
+	mask.erase(listener);
 }
 
 void Input::clearListeners(){
@@ -221,3 +241,21 @@ void Input::clearListeners(){
 
 	removedListeners.clear();
 }
+
+void Input::maskAll(){
+	for(auto listener : listeners){
+		mask.insert(listener);
+	}
+}
+
+void Input::unmaskAll(){
+	mask.clear();
+}
+
+void Input::addMask(InputListener* listener){
+	mask.insert(listener);
+}
+
+void Input::removeMask(InputListener* listener){
+	mask.erase(listener);
+}

libraries/CircuitOS/src/Input/Input.h

@@ -82,6 +82,18 @@ class Input : public LoopListener {
 
 	void removeListener(InputListener* listener);
 
+	bool getButtonState(uint8_t pin);
+
+	/**
+	 * Listener masking functions.
+	 *
+	 * Listeners added to mask will be ignored when input events happen.
+	 */
+	void maskAll();
+	void unmaskAll();
+	void addMask(InputListener* listener);
+	void removeMask(InputListener* listener);
+
 protected:
 	uint8_t pinNumber = 0;
 
@@ -116,6 +128,8 @@ class Input : public LoopListener {
 	std::unordered_set<InputListener*> removedListeners;
 
 	void clearListeners();
+
+	std::unordered_set<InputListener*> mask;
 };
 
 

libraries/CircuitOS/src/Input/InputShift.cpp

@@ -24,7 +24,7 @@ void InputShift::scanButtons(){
 
 	std::vector<bool> states(numShifts * 8, true);
 	for(int i = 0; i < numShifts * 8; i++){
-		states[i] = digitalRead(dataPin) == HIGH;
+		states[numShifts * 8 - i - 1] = digitalRead(dataPin) == HIGH;
 		HL(clockPin);
 	}
 

libraries/CircuitOS/src/Util/NullStream.cpp

@@ -0,0 +1,31 @@
+#include "NullStream.h"
+
+NullStream::NullStream(){
+	setTimeout(0);     // no timeout.
+}
+
+int NullStream::available(){
+	return 0;
+}
+
+int NullStream::peek(){
+	return EOF;
+}
+
+int NullStream::read(){
+	return EOF;
+}
+
+void NullStream::flush(){
+	return;
+}
+
+size_t NullStream::write(const uint8_t data){
+	bottomlessPit = data;
+	return 1;
+}
+
+size_t NullStream::write(const uint8_t* buffer, size_t size){
+	if(size > 0) bottomlessPit = buffer[size - 1];
+	return size;
+}