From 58ee51c767244789f5e6c72d93f8d8000b1233bc Mon Sep 17 00:00:00 2001 From: mihais Date: Thu, 29 Mar 2018 18:03:59 +0300 Subject: [PATCH] Add string based constructors for UPM sensors Signed-off-by: Mihai Stefanescu Signed-off-by: Stefan Andritoiu Signed-off-by: Mihai Tudor Panu --- examples/c++/buzzer-initio.cxx | 12 +++++ include/upm_string_parser.hpp | 36 ++++++++++++++ src/buzzer/buzzer.cxx | 67 ++++++++++++++++++++++----- src/buzzer/buzzer.h | 33 +++++++++++++ src/buzzer/buzzer.hpp | 19 ++++++-- src/initio/CMakeLists.txt | 5 ++ src/initio/initioSampleModule.cpp | 18 +++++++ src/initio/initioSampleModule.hpp | 17 +++++++ src/initio/jsupm_initioSampleModule.i | 8 ++++ src/initio/pyupm_initioSampleModule.i | 9 ++++ src/interfaces/UpmObject.hpp | 64 +++++++++++++++++++++++++ 11 files changed, 273 insertions(+), 15 deletions(-) create mode 100644 examples/c++/buzzer-initio.cxx create mode 100644 include/upm_string_parser.hpp create mode 100644 src/initio/CMakeLists.txt create mode 100644 src/initio/initioSampleModule.cpp create mode 100644 src/initio/initioSampleModule.hpp create mode 100644 src/initio/jsupm_initioSampleModule.i create mode 100644 src/initio/pyupm_initioSampleModule.i create mode 100644 src/interfaces/UpmObject.hpp diff --git a/examples/c++/buzzer-initio.cxx b/examples/c++/buzzer-initio.cxx new file mode 100644 index 00000000..1a75329c --- /dev/null +++ b/examples/c++/buzzer-initio.cxx @@ -0,0 +1,12 @@ +#include + +#include "buzzer.hpp" +#include "buzzer_tones.h" +#include "upm_utilities.h" + +int +main(int argc, char** argv) +{ + upm::Buzzer buzzer("p:33,vol:1.0"); + return 0; +} diff --git a/include/upm_string_parser.hpp b/include/upm_string_parser.hpp new file mode 100644 index 00000000..7f8cda68 --- /dev/null +++ b/include/upm_string_parser.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +// NOTE: A Logging mechanism for the whole library should be implemenented. +#include + +namespace upm { + class UpmStringParser { + public: + static std::vector parse(std::string initStr, std::string delim = ",") { + if (initStr.empty()) { + std::cout << "parse(): NULL or empty string given as argument." << std::endl; + return {}; + } + + std::vector strTokens; + size_t start = 0; + size_t end = initStr.find(delim); + + while (end != std::string::npos) { + strTokens.push_back(initStr.substr(start, end - start)); + start = end + delim.length(); + end = initStr.find(delim, start); + } + strTokens.push_back(initStr.substr(start, end)); + + for (auto i : strTokens) + std::cout << i << " "; + std::cout << std::endl; + + return strTokens; + } + }; +} diff --git a/src/buzzer/buzzer.cxx b/src/buzzer/buzzer.cxx index bb296665..aaa060bf 100644 --- a/src/buzzer/buzzer.cxx +++ b/src/buzzer/buzzer.cxx @@ -25,14 +25,17 @@ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ - -#include -#include #include #include +#include +#include +#include "mraa/initio.hpp" +#include "upm_string_parser.hpp" +#include #include "buzzer.hpp" + using namespace upm; using namespace std; @@ -43,33 +46,73 @@ Buzzer::Buzzer(int pinNumber) : m_buzzer(buzzer_init(pinNumber)) ": buzzer_init() failed"); } +Buzzer::Buzzer(std::string initStr) +{ + mraa::MraaIo mraaIo(initStr); + std::vector upmTokens; + + if (mraaIo.getLeftoverStr() != "") { + upmTokens = UpmStringParser::parse(mraaIo.getLeftoverStr()); + } + + m_buzzer = nullptr; + if (!mraaIo.pwms.empty()) { + m_buzzer = mraaIo.pwms[0]; + } + + if (m_buzzer == nullptr) { + throw std::runtime_error(std::string(__FUNCTION__) + + ": null buzzer context"); + } + + volume = 1.0; + m_buzzer.enable(true); + + /* + for (std::string tok : upmTokens) { + if (tok.substr(0, 4) == "vol:") { + // setVolume(::atof(tok.substr(4)); + } else {} + }*/ +} + Buzzer::~Buzzer() { - buzzer_close(m_buzzer); + stopSound(); + m_buzzer.enable(false); } void Buzzer::setVolume(float vol) { - buzzer_set_volume(m_buzzer, vol); + volume = vol; } float Buzzer::getVolume() { - return buzzer_get_volume(m_buzzer); + return volume; } int Buzzer::playSound(int note, int delay) { - if (buzzer_play_sound(m_buzzer, note, delay)) - throw std::runtime_error(std::string(__FUNCTION__) + - ": buzzer_play_sound() failed"); + if (m_buzzer.period_us(note) != MRAA_SUCCESS) { + cout << "period() error\n"; + } + + if (m_buzzer.write(volume * 0.5)) { + cout << "write() error\n"; + } + + if (delay >= 0) { + upm_delay_us(delay); + stopSound(); + } + return note; } void Buzzer::stopSound() { - if (buzzer_stop_sound(m_buzzer)) - throw std::runtime_error(std::string(__FUNCTION__) + - ": buzzer_stop_sound() failed"); + m_buzzer.period_us(1); + m_buzzer.write(0); } diff --git a/src/buzzer/buzzer.h b/src/buzzer/buzzer.h index 712dc1e1..9e7d94c6 100644 --- a/src/buzzer/buzzer.h +++ b/src/buzzer/buzzer.h @@ -29,6 +29,7 @@ #include #include +#include #include #include @@ -110,6 +111,38 @@ extern "C" { */ float buzzer_get_volume(const buzzer_context dev); + char** upm_parse_init_str(const char* str, const char* delims, int *num_tokens) + { + char *saveptr, *tok, *s, *p_str; + char **output = NULL; + size_t output_size = 0; + + p_str = strdup(str); + + for (s = p_str; ; s = NULL) { + tok = strtok_r(s, delims, &saveptr); + if (tok == NULL) + break; + output = (char**)realloc(output, (++output_size) * sizeof(char*)); + output[output_size - 1] = (char*)calloc(strlen(tok) + 1, sizeof(char)); + strncpy(output[output_size - 1], tok, strlen(tok)); + } + *num_tokens = output_size; + + free(p_str); + + return output; + } + + void upm_delete_parsed_str(char **str, int num_tokens) + { + for (int i = 0; i < num_tokens; ++i) { + free(str[i]); + } + + free(str); + } + #ifdef __cplusplus } #endif diff --git a/src/buzzer/buzzer.hpp b/src/buzzer/buzzer.hpp index ab1dac00..52570503 100644 --- a/src/buzzer/buzzer.hpp +++ b/src/buzzer/buzzer.hpp @@ -28,7 +28,9 @@ #pragma once #include -#include +#include +#include +//#include namespace upm { @@ -68,6 +70,14 @@ namespace upm { */ Buzzer(int pinNumber); + /** + * Instantiates a Buzzer object based on a given string. + * + * @param initStr string containing specific information for Buzzer initialization. + * Usage: TODO + */ + Buzzer(std::string initStr); + /** * Buzzer object destructor. */ @@ -115,10 +125,13 @@ namespace upm { { return m_name; } + protected: std::string m_name; - buzzer_context m_buzzer; - + mraa::Pwm m_buzzer; + float volume; + bool initialized; + //buzzer_context m_buzzer; private: /* Disable implicit copy and assignment operators */ Buzzer(const Buzzer&) = delete; diff --git a/src/initio/CMakeLists.txt b/src/initio/CMakeLists.txt new file mode 100644 index 00000000..75c879bd --- /dev/null +++ b/src/initio/CMakeLists.txt @@ -0,0 +1,5 @@ +upm_mixed_module_init (NAME initioSampleModule + DESCRIPTION "initio sample module" + CPP_HDR initioSampleModule.hpp + CPP_SRC initioSampleModule.cpp + REQUIRES mraa) diff --git a/src/initio/initioSampleModule.cpp b/src/initio/initioSampleModule.cpp new file mode 100644 index 00000000..9e0f46b5 --- /dev/null +++ b/src/initio/initioSampleModule.cpp @@ -0,0 +1,18 @@ +#include +#include +#include + +#include "initioSampleModule.hpp" + +using namespace upm; +using namespace std; + +initioSampleModule::initioSampleModule(std::string initStr) : mraa::MraaIo(initStr) +{ + // Do some processing here + //std::cout << "111 " << leftoverStr << std::endl; +} + +initioSampleModule::~initioSampleModule() +{ +} diff --git a/src/initio/initioSampleModule.hpp b/src/initio/initioSampleModule.hpp new file mode 100644 index 00000000..3e0ade39 --- /dev/null +++ b/src/initio/initioSampleModule.hpp @@ -0,0 +1,17 @@ +#pragma once + +#include +#include + +namespace upm { + class initioSampleModule : public mraa::MraaIo { + public: + initioSampleModule(std::string initStr); + ~initioSampleModule(); + + private: + //mraa_gpio_context m_gpio; + }; +} + + diff --git a/src/initio/jsupm_initioSampleModule.i b/src/initio/jsupm_initioSampleModule.i new file mode 100644 index 00000000..d1a7caee --- /dev/null +++ b/src/initio/jsupm_initioSampleModule.i @@ -0,0 +1,8 @@ +%module jsupm_initioSampleModule +%include "../upm.i" + +%{ + #include "initioSampleModule.hpp" +%} + +%include "initioSampleModule.hpp" diff --git a/src/initio/pyupm_initioSampleModule.i b/src/initio/pyupm_initioSampleModule.i new file mode 100644 index 00000000..04f155ef --- /dev/null +++ b/src/initio/pyupm_initioSampleModule.i @@ -0,0 +1,9 @@ +// Include doxygen-generated documentation +%include "pyupm_doxy2swig.i" +%module pyupm_initioSampleModule +%include "../upm.i" + +%include "initioSampleModule.hpp" +%{ + #include "initioSampleModule.hpp" +%} diff --git a/src/interfaces/UpmObject.hpp b/src/interfaces/UpmObject.hpp new file mode 100644 index 00000000..86a87545 --- /dev/null +++ b/src/interfaces/UpmObject.hpp @@ -0,0 +1,64 @@ +/* NOTE: WIP */ + +#pragma once + +#include +#include +#include "upm/upm_types.h" +#include + +#include + +static const std::string DELIM = ":"; + +namespace upm +{ + class UpmObject + { + public: + UpmObject(); + UpmObject(std::string initStr) : mraaIo(initStr) + { + parseUpmInitString(mraaIo.getLeftoverString()); + + for (auto i : strTokens) { + std::cout << i << " "; + } + std::cout << std::endl; + } + ~UpmObject() {}; + + protected: + std::vector getParsedTokens() + { + return strTokens; + } + + mraa::MraaIo mraaIo; + + private: + upm_result_t parseUpmInitString(std::string initStr) + { + upm_result_t result = UPM_SUCCESS; + + if (initStr == "") { + // No specific UPM init string provided. + return result; + } + + size_t start = 0; + size_t end = initStr.find(DELIM); + + while (end != std::string::npos) { + strTokens.push_back(initStr.substr(start, end - start)); + start = end + DELIM.length(); + end = initStr.find(DELIM, start); + } + strTokens.push_back(initStr.substr(start, end)); + + return result; + } + + std::vector strTokens; + }; +}