nkolban · nkolban · Nov 9, 2018 · Jun 8, 2018 · Jun 14, 2018 · Jun 15, 2018
diff --git a/cpp_utils/BLEService.cpp b/cpp_utils/BLEService.cpp
@@ -35,7 +35,7 @@ static const char* LOG_TAG = "BLEService"; // Tag for logging.
  * @param [in] uuid The UUID of the service.
  * @param [in] numHandles The maximum number of handles associated with the service.
  */
-BLEService::BLEService(const char* uuid, uint32_t numHandles) : BLEService(BLEUUID(uuid), numHandles) {
+BLEService::BLEService(const char* uuid, uint16_t numHandles) : BLEService(BLEUUID(uuid), numHandles) {
 }
 
 
@@ -44,7 +44,7 @@ BLEService::BLEService(const char* uuid, uint32_t numHandles) : BLEService(BLEUU
  * @param [in] uuid The UUID of the service.
  * @param [in] numHandles The maximum number of handles associated with the service.
  */
-BLEService::BLEService(BLEUUID uuid, uint32_t numHandles) {
+BLEService::BLEService(BLEUUID uuid, uint16_t numHandles) {
 	m_uuid      = uuid;
 	m_handle    = NULL_HANDLE;
 	m_pServer   = nullptr;

diff --git a/cpp_utils/BLEService.h b/cpp_utils/BLEService.h
@@ -65,8 +65,8 @@ class BLEService {
 	uint8_t            m_id = 0;
 
 private:
-	BLEService(const char* uuid, uint32_t numHandles);
-	BLEService(BLEUUID uuid, uint32_t numHandles);
+	BLEService(const char* uuid, uint16_t numHandles);
+	BLEService(BLEUUID uuid, uint16_t numHandles);
 	friend class BLEServer;
 	friend class BLEServiceMap;
 	friend class BLEDescriptor;
@@ -84,7 +84,7 @@ class BLEService {
 	FreeRTOS::Semaphore  m_semaphoreStartEvt  = FreeRTOS::Semaphore("StartEvt");
 	FreeRTOS::Semaphore  m_semaphoreStopEvt   = FreeRTOS::Semaphore("StopEvt");
 
-	uint32_t             m_numHandles;
+	uint16_t             m_numHandles;
 
 	BLECharacteristic* getLastCreatedCharacteristic();
 	void			   handleGATTServerEvent(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t* param);

diff --git a/cpp_utils/FreeRTOS.cpp b/cpp_utils/FreeRTOS.cpp
@@ -32,7 +32,7 @@ void FreeRTOS::sleep(uint32_t ms) {
  * @param[in] param An optional parameter to be passed to the started task.
  * @param[in] stackSize An optional paremeter supplying the size of the stack in which to run the task.
  */
-void FreeRTOS::startTask(void task(void*), std::string taskName, void* param, int stackSize) {
+void FreeRTOS::startTask(void task(void*), std::string taskName, void* param, uint32_t stackSize) {
 	::xTaskCreate(task, taskName.data(), stackSize, param, 5, NULL);
 } // startTask
 
@@ -162,7 +162,7 @@ bool FreeRTOS::Semaphore::take(std::string owner) {
 	if (m_usePthreads) {
 		pthread_mutex_lock(&m_pthread_mutex);
 	} else {
-		rc = ::xSemaphoreTake(m_semaphore, portMAX_DELAY);
+		rc = ::xSemaphoreTake(m_semaphore, portMAX_DELAY) == pdTRUE;
 	}
 	m_owner = owner;
 	if (rc) {
@@ -187,7 +187,7 @@ bool FreeRTOS::Semaphore::take(uint32_t timeoutMs, std::string owner) {
 	if (m_usePthreads) {
 		assert(false);  // We apparently don't have a timed wait for pthreads.
 	} else {
-		rc = ::xSemaphoreTake(m_semaphore, timeoutMs / portTICK_PERIOD_MS);
+		rc = ::xSemaphoreTake(m_semaphore, timeoutMs / portTICK_PERIOD_MS) == pdTRUE;
 	}
 	m_owner = owner;
 	if (rc) {
@@ -262,8 +262,8 @@ void Ringbuffer::returnItem(void* item) {
  * @param [in] wait How long to wait before giving up.  The default is to wait indefinitely.
  * @return
  */
-uint32_t Ringbuffer::send(void* data, size_t length, TickType_t wait) {
-	return ::xRingbufferSend(m_handle, data, length, wait);
+bool Ringbuffer::send(void* data, size_t length, TickType_t wait) {
+	
B422
return ::xRingbufferSend(m_handle, data, length, wait) == pdTRUE;
 } // send
 
 
diff --git a/cpp_utils/FreeRTOS.h b/cpp_utils/FreeRTOS.h
@@ -23,7 +23,7 @@
 class FreeRTOS {
 public:
 	static void sleep(uint32_t ms);
-	static void startTask(void task(void*), std::string taskName, void* param = nullptr, int stackSize = 2048);
+	static void startTask(void task(void*), std::string taskName, void* param = nullptr, uint32_t stackSize = 2048);
 	static void deleteTask(TaskHandle_t pTask = nullptr);
 
 	static uint32_t getTimeSinceStart();
@@ -63,7 +63,7 @@ class Ringbuffer {
 
 	void*    receive(size_t* size, TickType_t wait = portMAX_DELAY);
 	void     returnItem(void* item);
-	uint32_t send(void* data, size_t length, TickType_t wait = portMAX_DELAY);
+	bool     send(void* data, size_t length, TickType_t wait = portMAX_DELAY);
 private:
 	RingbufHandle_t m_handle;
 };

diff --git a/cpp_utils/GPIO.cpp b/cpp_utils/GPIO.cpp
@@ -117,7 +117,7 @@ void ESP32CPP::GPIO::low(gpio_num_t pin) {
  * @return True if the pin is high, false if the pin is low.
  */
 bool ESP32CPP::GPIO::read(gpio_num_t pin) {
-	return ::gpio_get_level(pin);
+	return ::gpio_get_level(pin) == 1;
 } // read
 
 
@@ -179,7 +179,7 @@ void ESP32CPP::GPIO::setOutput(gpio_num_t pin) {
  */
 void ESP32CPP::GPIO::write(gpio_num_t pin, bool value) {
 	//ESP_LOGD(LOG_TAG, ">> write: pin: %d, value: %d", pin, value);
-	esp_err_t errRc = ::gpio_set_level(pin, value);
+	esp_err_t errRc = ::gpio_set_level(pin, value ? 1 : 0);
 	if (errRc != ESP_OK) {
 		ESP_LOGE(LOG_TAG, "<< gpio_set_level: pin=%d, rc=%d %s", pin, errRc, GeneralUtils::errorToString(errRc));
 	}

diff --git a/cpp_utils/I2C.cpp b/cpp_utils/I2C.cpp
@@ -94,7 +94,7 @@ uint8_t I2C::getAddress() const {
  * @param [in] sclPin The pin to use for SCL clock.
  * @return N/A.
  */
-void I2C::init(uint8_t address, gpio_num_t sdaPin, gpio_num_t sclPin, uint32_t clockSpeed, i2c_port_t portNum) {
+void I2C::init(uint8_t address, gpio_num_t sdaPin, gpio_num_t sclPin, uint32_t clockSpeed, i2c_port_t portNum, bool pullup) {
 	ESP_LOGD(LOG_TAG, ">> I2c::init.  address=%d, sda=%d, scl=%d, clockSpeed=%d, portNum=%d", address, sdaPin, sclPin, clockSpeed, portNum);
 	assert(portNum < I2C_NUM_MAX);
 	m_portNum = portNum;
@@ -106,8 +106,8 @@ void I2C::init(uint8_t address, gpio_num_t sdaPin, gpio_num_t sclPin, uint32_t c
 	conf.mode             = I2C_MODE_MASTER;
 	conf.sda_io_num       = sdaPin;
 	conf.scl_io_num       = sclPin;
-	conf.sda_pullup_en    = GPIO_PULLUP_ENABLE;
-	conf.scl_pullup_en    = GPIO_PULLUP_ENABLE;
+	conf.sda_pullup_en    = pullup ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
+	conf.scl_pullup_en    = pullup ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
 	conf.master.clk_speed =  clockSpeed;
 	esp_err_t errRc = ::i2c_param_config(m_portNum, &conf);
 	if (errRc != ESP_OK) {

diff --git a/cpp_utils/I2C.h b/cpp_utils/I2C.h
@@ -37,7 +37,7 @@ class I2C {
 	void beginTransaction();
 	void endTransaction();
 	uint8_t getAddress() const;
-	void init(uint8_t address, gpio_num_t sdaPin = DEFAULT_SDA_PIN, gpio_num_t sclPin = DEFAULT_CLK_PIN, uint32_t clkSpeed = DEFAULT_CLK_SPEED, i2c_port_t portNum = I2C_NUM_0);
+	void init(uint8_t address, gpio_num_t sdaPin = DEFAULT_SDA_PIN, gpio_num_t sclPin = DEFAULT_CLK_PIN, uint32_t clkSpeed = DEFAULT_CLK_SPEED, i2c_port_t portNum = I2C_NUM_0, bool pullup = true);
 	void read(uint8_t* bytes, size_t length, bool ack = true);
 	void read(uint8_t* byte, bool ack = true);
 	void scan();

diff --git a/cpp_utils/Memory.cpp b/cpp_utils/Memory.cpp
@@ -47,7 +47,7 @@ size_t               Memory::m_lastHeapSize = 0;
 
 /* STATIC */ void Memory::dumpHeapChange(std::string tag) {
 	size_t currentUsage = heap_caps_get_free_size(MALLOC_CAP_8BIT);
-	int diff = currentUsage - m_lastHeapSize;
+	size_t diff = currentUsage - m_lastHeapSize;
 	ESP_LOGD(LOG_TAG, "%s: Heap changed by %d bytes  (%d to %d)", tag.c_str(), diff, m_lastHeapSize, currentUsage);
 	m_lastHeapSize = currentUsage;
 } // dumpHeapChange

diff --git a/cpp_utils/NeoPixelWiFiEventHandler.cpp b/cpp_utils/NeoPixelWiFiEventHandler.cpp
@@ -5,8 +5,11 @@
  *      Author: kolban
  */
 #include <stdio.h>
+#include <esp_log.h>
 #include "NeoPixelWiFiEventHandler.h"
 
+static const char* LOG_TAG = "NeoPixelWiFiEventHandler";
+
 NeoPixelWiFiEventHandler::NeoPixelWiFiEventHandler(gpio_num_t gpioPin) {
 	this->gpioPin = gpioPin;
 	ws2812 = new WS2812(gpioPin, 8);
@@ -17,42 +20,42 @@ NeoPixelWiFiEventHandler::~NeoPixelWiFiEventHandler() {
 }
 
 esp_err_t NeoPixelWiFiEventHandler::apStart() {
-	printf("XXX apStart\n");
+	ESP_LOGD(LOG_TAG, "XXX apStart");
 	ws2812->setPixel(0, 0, 00, 64);
 	ws2812->show();
 	return ESP_OK;
 }
 
 esp_err_t NeoPixelWiFiEventHandler::staConnected(system_event_sta_connected_t info) {
-	printf("XXX staConnected\n");
+	ESP_LOGD(LOG_TAG, "XXX staConnected");
 	ws2812->setPixel(0, 57, 89, 66);
 	ws2812->show();
 	return ESP_OK;
 }
 
 esp_err_t NeoPixelWiFiEventHandler::staDisconnected(system_event_sta_disconnected_t info) {
-	printf("XXX staDisconnected\n");
+	ESP_LOGD(LOG_TAG, "XXX staDisconnected");
 	ws2812->setPixel(0, 64, 0, 0);
 	ws2812->show();
 	return ESP_OK;
 }
 
 esp_err_t NeoPixelWiFiEventHandler::staStart() {
-	printf("XXX staStart\n");
+	ESP_LOGD(LOG_TAG, "XXX staStart");
 	ws2812->setPixel(0, 64, 64, 0);
 	ws2812->show();
 	return ESP_OK;
 }
 
 esp_err_t NeoPixelWiFiEventHandler::staGotIp(system_event_sta_got_ip_t info) {
-	printf("XXX staGotIp\n");
+	ESP_LOGD(LOG_TAG, "XXX staGotIp");
 	ws2812->setPixel(0, 0, 64, 0);
 	ws2812->show();
 	return ESP_OK;
 }
 
 esp_err_t NeoPixelWiFiEventHandler::wifiReady() {
-	printf("XXX wifiReady\n");
+	ESP_LOGD(LOG_TAG, "XXX wifiReady");
 	ws2812->setPixel(0, 64, 64, 0);
 	ws2812->show();
 	return ESP_OK;

diff --git a/cpp_utils/PCF8574.cpp b/cpp_utils/PCF8574.cpp
@@ -18,7 +18,8 @@
  * @param [in] address The %I2C address of the device on the %I2C bus.
  */
 PCF8574::PCF8574(uint8_t address) {
-	i2c.setAddress(address);
+	i2c = new I2C();
+	i2c->setAddress(address);
 	lastWrite = 0;
 }
 
@@ -27,6 +28,7 @@ PCF8574::PCF8574(uint8_t address) {
  * @brief Class instance destructor.
  */
 PCF8574::~PCF8574() {
+	delete i2c;
 }
 
 
@@ -36,9 +38,9 @@ PCF8574::~PCF8574() {
  */
 uint8_t PCF8574::read() {
 	uint8_t value;
-	i2c.beginTransaction();
-	i2c.read(&value,true);
-	i2c.endTransaction();
+	i2c->beginTransaction();
+	i2c->read(&value,true);
+	i2c->endTransaction();
 	return value;
 } // read
 
@@ -65,9 +67,9 @@ void PCF8574::write(uint8_t value) {
 	if (invert) {
 		value = ~value;
 	}
-	i2c.beginTransaction();
-	i2c.write(value, true);
-	i2c.endTransaction();
+	i2c->beginTransaction();
+	i2c->write(value, true);
+	i2c->endTransaction();
 	lastWrite = value;
 } // write
 
@@ -114,5 +116,5 @@ void PCF8574::setInvert(bool value) {
  * @param [in] clkPin The pin to use for the %I2C CLK functions.
  */
 void PCF8574::init(gpio_num_t sdaPin, gpio_num_t clkPin) {
-	i2c.init(0, sdaPin, clkPin);
+	i2c->init(0, sdaPin, clkPin);
 } // init
diff --git a/cpp_utils/PCF8574.h b/cpp_utils/PCF8574.h
@@ -29,7 +29,7 @@ class PCF8574 {
 	void writeBit(uint8_t bit, bool value);
 
 private:
-	I2C i2c = I2C();
+	I2C* i2c;
 	uint8_t lastWrite;
 	bool invert = false;
 

diff --git a/cpp_utils/PCF8575.cpp b/cpp_utils/PCF8575.cpp
@@ -19,7 +19,8 @@
  * @param [in] address The %I2C address of the device on the %I2C bus.
  */
 PCF8575::PCF8575(uint8_t address) {
-	i2c.setAddress(address);
+	i2c = new I2C();
+	i2c->setAddress(address);
 	m_lastWrite = 0;
 }
 
@@ -28,6 +29,7 @@ PCF8575::PCF8575(uint8_t address) {
  * @brief Class instance destructor.
  */
 PCF8575::~PCF8575() {
+	delete i2c;
 }
 
 
@@ -37,10 +39,10 @@ PCF8575::~PCF8575() {
  */
 uint16_t PCF8575::read() {
 	uint16_t value;
-	i2c.beginTransaction();
-	i2c.read((uint8_t*) &value, true);
-	i2c.read(((uint8_t*) &value) + 1, true);
-	i2c.endTransaction();
+	i2c->beginTransaction();
+	i2c->read((uint8_t*) &value, true);
+	i2c->read(((uint8_t*) &value) + 1, true);
+	i2c->endTransaction();
 	return value;
 } // read
 
@@ -67,10 +69,10 @@ void PCF8575::write(uint16_t value) {
 	if (invert) {
 		value = ~value;
 	}
-	i2c.beginTransaction();
-	i2c.write(value & 0xff, true);
-	i2c.write((value >> 8) & 0xff, true);
-	i2c.endTransaction();
+	i2c->beginTransaction();
+	i2c->write(value & 0xff, true);
+	i2c->write((value >> 8) & 0xff, true);
+	i2c->endTransaction();
 	m_lastWrite = value;
 } // write
 
@@ -117,5 +119,5 @@ void PCF8575::setInvert(bool value) {
  * @param [in] clkPin The pin to use for the %I2C CLK functions.
  */
 void PCF8575::init(gpio_num_t sdaPin, gpio_num_t clkPin) {
-	i2c.init(0, sdaPin, clkPin);
+	i2c->init(0, sdaPin, clkPin);
 } // init
diff --git a/cpp_utils/PCF8575.h b/cpp_utils/PCF8575.h
@@ -29,8 +29,8 @@ class PCF8575 {
 	void     writeBit(uint16_t bit, bool value);
 
 private:
-	I2C     i2c = I2C();
-	uint8_t m_lastWrite;
+	I2C* i2c;
+	uint16_t m_lastWrite;
 	bool    invert = false;
 };
 

diff --git a/cpp_utils/PWM.cpp b/cpp_utils/PWM.cpp
@@ -145,5 +145,5 @@ void PWM::setFrequency(uint32_t freq) {
  * @return N/A.
  */
 void PWM::stop(bool idleLevel) {
-	ESP_ERROR_CHECK(::ledc_stop(LEDC_HIGH_SPEED_MODE, m_channel, idleLevel));
+	ESP_ERROR_CHECK(::ledc_stop(LEDC_HIGH_SPEED_MODE, m_channel, idleLevel ? 1 : 0));
 } // stop
diff --git a/cpp_utils/PubSubClient.cpp b/cpp_utils/PubSubClient.cpp
@@ -188,10 +188,10 @@ void PubSubClient::setup() {
 	UNSUBACK_Outstanding = false;
 
 	keepAliveTimer = new FreeRTOSTimer((char*) "keepAliveTimer",
-			(MQTT_KEEPALIVE * 1000) / portTICK_PERIOD_MS, true, this,
+			(MQTT_KEEPALIVE * 1000) / portTICK_PERIOD_MS, pdTRUE, this,
 			keepAliveTimerMapper);
 	timeoutTimer = new FreeRTOSTimer((char*) "timeoutTimer",
-				(MQTT_KEEPALIVE * 1000) / portTICK_PERIOD_MS, true, this,
+				(MQTT_KEEPALIVE * 1000) / portTICK_PERIOD_MS, pdTRUE, this,
 				timeoutTimerMapper);
 	m_task = new PubSubClientTask("PubSubClientTask");
 } // setup
@@ -399,8 +399,7 @@ bool PubSubClient::connect() {
  * @param 	N/A.
  * @return 	Number of received bytes.
  */
-uint16_t PubSubClient::readPacket() {
-
+size_t PubSubClient::readPacket() {
 	size_t res = _client->receive(buffer, MQTT_MAX_PACKET_SIZE);
 
 	if (res > MQTT_MAX_PACKET_SIZE) {

diff --git a/cpp_utils/PubSubClient.h b/cpp_utils/PubSubClient.h
@@ -160,7 +160,7 @@ class PubSubClient {
 
    MQTT_CALLBACK_SIGNATURE;
    void setup();
-   uint16_t readPacket();
+   size_t readPacket();
    bool write(uint8_t header, uint8_t* buf, uint16_t length);
    uint16_t writeString(const char* string, uint8_t* buf, uint16_t pos);
    void parseData(mqtt_message* msg, uint16_t len);