upm: version bump to v0.1.5

Signed-off-by: Thomas Ingleby <thomas.c.ingleby@intel.com>

CMakeLists.txt

@@ -8,9 +8,9 @@ endif ()
 
 find_package (Threads REQUIRED)
 find_package (PkgConfig REQUIRED)
-# force the libmaa version to be the required version
-pkg_check_modules (MAA REQUIRED maa>=0.2.6)
-message (INFO " found libmaa version: ${MAA_VERSION}")
+# force the libmraa version to be the required version
+pkg_check_modules (MRAA REQUIRED mraa>=0.4.0)
+message (INFO " found libmraa version: ${MRAA_VERSION}")
 
 # Appends the cmake/modules path to MAKE_MODULE_PATH variable.
 set (CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
@@ -19,8 +19,8 @@ set (CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_
 include (GetGitRevisionDescription)
 git_describe (VERSION "--tags")
 if ("x_${VERSION}" STREQUAL "x_GIT-NOTFOUND")
-  message (WARNING " - Install git to compile a production libmaa!")
-  set (VERSION "v0.1.2-dirty")
+  message (WARNING " - Install git to compile a production libmraa!")
+  set (VERSION "v0.1.5-dirty")
 endif ()
 
 message (INFO " - UPM Version ${VERSION}")
@@ -81,7 +81,7 @@ if (IPK)
   set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
   set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE ${DETECTED_ARCH})
   set(CPACK_SYSTEM_NAME ${DETECTED_ARCH})
-  set(CPACK_DEBIAN_PACKAGE_DEPENDS "libmaa0 (>= ${MAA_VERSION})")
+  set(CPACK_DEBIAN_PACKAGE_DEPENDS "libmraa0 (>= ${MRAA_VERSION})")
   set(CPACK_DEBIAN_PACKAGE_PROVIDES "upm-dev, upm-dbg, upm-doc")
   set(CPACK_DEBIAN_PACKAGE_REPLACES ${CPACK_DEBIAN_PACKAGE_PROVIDES})
   set(CPACK_DEBIAN_PACKAGE_CONFLICTS ${CPACK_DEBIAN_PACKAGE_PROVIDES})

Doxyfile.in

@@ -44,7 +44,7 @@ PROJECT_NUMBER         = @upm_VERSION_STRING@
 # for a project that appears at the top of each page and should give viewer a
 # quick idea about the purpose of the project. Keep the description short.
 
-PROJECT_BRIEF          = "Sensor/Actuator repository for libmaa (v@MAA_VERSION@)"
+PROJECT_BRIEF          = "Sensor/Actuator repository for libmraa (v@MRAA_VERSION@)"
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is included in
 # the documentation. The maximum height of the logo should not exceed 55 pixels
@@ -754,6 +754,7 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/src \
+                         @CMAKE_CURRENT_SOURCE_DIR@/docs \
                          @CMAKE_CURRENT_SOURCE_DIR@/README.md
 
 # This tag can be used to specify the character encoding of the source files
@@ -863,7 +864,9 @@ EXCLUDE_SYMBOLS        =
 # that contain example code fragments that are included (see the \include
 # command).
 
-EXAMPLE_PATH           = @CMAKE_CURRENT_SOURCE_DIR@/examples/
+EXAMPLE_PATH           = @CMAKE_CURRENT_SOURCE_DIR@/examples/ \
+                         @CMAKE_CURRENT_SOURCE_DIR@/docs/ \
+			 @CMAKE_CURRENT_SOURCE_DIR@/src/max31855/
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and

README.md

@@ -1,8 +1,8 @@
-UPM - Sensor/Actuator repository for Maa
+UPM - Sensor/Actuator repository for Mraa
 ==============
 
-UPM is a high level repository for sensors that use maa. Each sensor links to
-libmaa and are not meant to be interlinked although some groups of sensors may
+UPM is a high level repository for sensors that use mraa. Each sensor links to
+libmraa and are not meant to be interlinked although some groups of sensors may
 be. Each sensor contains a header which allows to interface with it. Typically
 a sensor is represented as a class and instanciated.
 
@@ -12,15 +12,20 @@ to provide identification/pin location on the board.
 Typically an update() function will be called in order to get new data from the
 sensor in order to reduce load when doing multiple reads to sensor data.
 
-A basic sensor is expected to work as such:
-s = new sensor();
-print(sensor->read());
-sleep(1);
-s->update();
-print(sensor->read();
+### Example
+
+A sensor/acturo is expected to work as such (here is the servo ES08A api):
+@snippet es08a.cxx Interesting
 
 However implementation and API design is compeltely up to the developer, some
 enumerable sensors for example may provide much clever instanciation. Displays
 may also create more complex structures in order to interface with them.
 
-For more information on maa, see the maa documentation
+### Building UPM
+
+See @ref building
+
+### Making your own UPM module
+
+@ref porting has more information on making new UPM modules
+

docs/building.md

@@ -0,0 +1,31 @@
+Building UPM                         {#building}
+============
+
+UPM uses cmake in order to make compilation relatively painless. Cmake runs
+build out of tree so the recommended way is to clone from git and make a build/
+directory.
+
+UPM will attempt to build all directories inside src/ and they must contain
+individual CMakeLists.txt files.
+
+~~~~~~~~~~~~~{.sh}
+mkdir build
+cd build
+cmake ..
+make
+~~~~~~~~~~~~~
+
+Our cmake configure has a number of options, `cmake -i` will ask you all sorts
+of interesting questions, you can disable swig modules, build documentation
+etc...
+
+Few recommended options:
+Changing install path from /usr/local to /usr
+-DCMAKE_INSTALL_PREFIX:PATH=/usr
+
+Building debug build:
+-DCMAKE_BUILD_TYPE=DEBUG
+
+Using clang instead of gcc:
+ -DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang
+

docs/contributions.md

@@ -0,0 +1,16 @@
+Contributing a module                         {#contributions}
+=====================
+
+Here are the rules of contribution:
+- Try not to break master. In any commit.
+- Commits must have a sign-off line by everyone who reviewed them
+- Commits must be named <file/module>: Some decent description
+- You must license your module under an FOSS license. The recommended license
+  is MIT but any permissive license is fine. Please consider that people using
+  UPM may want to write proprietary programs with your sensors so we like to
+  avoid GPL. (LGPL is fine). If your license is not MIT please include a
+  LICENSE file in src/<mymodule>/
+- Please test your module builds before contributing and make sure it works on
+  the latest version of mraa. If you tested on a specific board/platform please
+  tell us what this was in your PR.
+

docs/max31855.md

@@ -0,0 +1,96 @@
+Making a UPM module for MAX31855                         {#max31855}
+================================
+
+The Maxim Integrated MAX31855 is a thermocouple amplifier allowing you to read
+from a K type themocouple. My board comes from the Pmod kit form Maxim
+(MAX31855PMB1) but you can get this from many different sources. The adafruit
+people made arduino code already so we'll use that as a
+[reference](https://github.com/adafruit/Adafruit-MAX31855-library/blob/master/Adafruit_MAX31855.cpp).
+
+### Basics
+
+This is a spi module so we will use the mraa spi functions to build our module.
+First thing to do is to create a tree structure like this in upm/src/max31855:
+
+* max31855.cxx
+* max31855.h
+* jsupm_max31855.i
+* pyupm_max31855.i
+* CMakeLists.txt
+
+And then an example file to use & test our lib with in upm/examples/max31855.cxx.
+
+### Swig
+
+The .i files are used by swig, there is one for each python & javascript. They
+contain essentially the same thing and are very simple. The only thing to
+change between the javascript & node.js one is the argument to %module.
+
+@snippet jsupm_max31855.i Interesting
+
+The %include parameter defines which functions will be available to the
+node/python module created, Whilst the headers inside %{} will be explicitly
+required during compilation. Typically only the top level header is required in
+either of those args.
+
+### API
+
+Then we create the header (max31855.h) , a very simple header in our case we
+will have only a very basic api. We provide a getTemp() function which will
+return the same type as in the arduino library, a double.
+
+@snippet max31855.h Interesting
+
+Note that the header contains both the io that we will use, the gpio is in this
+case used as the chip select pin.
+
+### Implementing our API
+
+In the adafruit library the read function (our chip is a 3pin SPI so only read
+is possible), the spiread32() does all the work. It starts by setting up the io
+so we will do the same in our constructor.
+
+Note unlike on Arduino, we'll just set a 2Mhz clock and let the chip do the
+work.
+
+@snippet src/max31855/max31855.cxx Constructor
+
+Then we also need to implement a nice cleanup in our destructor.
+
+@snippet src/max31855/max31855.cxx Destructor
+
+Then to read data, we will use spi_write_buf which will allow us to write a
+whole uint32_t in order to get one back, which is what the arduino code does in
+spiread32. Obviously we set our chip select to low first. Here is the start of
+the implementation of MAX31855::getTemp()
+
+@snippet src/max31855/max31855.cxx spi
+
+Then using the arduino code as reference we simply reconstruct form the 4
+uint8_t values a 32bit int value and select only the valuable parts of
+information from that. The MAX31855 datahseet explains exactly which bits are
+useful, we will just do the same as the adafruit code, first checking the error
+bit and then scrapping everything but the 14bit of thermocouple data that are
+useful to us and converting it to a double.
+
+@snippet src/max31855/max31855.cxx conversion
+
+### Finalizing
+
+Our final example, very easy to use api!
+
+@snippet examples/max31855.cxx Interesting
+
+### Building
+
+The we need to add it to the examples/CMakeLists.txt. Only three lines are required
+
+~~~~~~~~~~~
+add_executable (max31855-example max31855.cxx)
+include_directories (${PROJECT_SOURCE_DIR}/src/max31855)
+target_link_libraries (max31855-example max31855 ${CMAKE_THREAD_LIBS_INIT})
+~~~~~~~~~~~
+
+Note you dont have to rebuild everything, cmake keeps target lists so if you
+named your example target <modulename>-example you can simply do make
+max31855-example and both the library & example will build.

docs/naming.md

@@ -0,0 +1,24 @@
+Naming a module                         {#naming}
+===============
+
+UPM attemps to follow a clear naming pattern. Modules should be sensibly named
+and then placed in /usr/lib/upm and headers in /usr/include/upm.
+
+### Choosing a name
+
+1. Pick a name
+2. Use it
+
+### Rules for name picking
+
+1. Your lib must belong to namespace UPM
+2. Usually picking the name of the chip of your sensor/actuator might make
+sense. Other times this does not. Try to pick a generic name so people with a
+similar sensor can inherit your class if they only have minor changes.
+3. Avoid brand names
+
+### Doubt
+
+If ever, give me a ping via email: brendan.le.foll@intel.com and I'll try
+suggest decent names for your module.
+

docs/porting.md

@@ -0,0 +1,65 @@
+Porting a module from Arduino                         {#porting}
+=============================
+
+Porting arduino libraries to libmraa as UPM libraries is usually fairly easy.
+The issues typically come from misunderstanding of how a non real time OS deals
+with interupts and timers. It also highly depends on the sensor. A concrete
+example is explained in detail on @ref max31855
+
+### Adding a new module to UPM
+
+1. Choose a name for your module (see @ref naming)
+2. Make a new folder in src/<modulename>
+3. Create a CMakeLists.txt file inside src/<modulename>
+
+### CmakeLists.txt
+
+By default you need a header called <modulename>.h and a C++ file called
+<modulename>.cxx. You can have multiple headers and source files. Only public
+headers need to be added to module_h and all source files need to be in
+module_src.
+
+~~~~~~~~~~~
+set (libname "modulename")
+set (libdescription "Module Description")
+set (module_src ${libname}.cxx)
+set (module_h ${libname}.h)
+upm_module_init()
+~~~~~~~~~~~
+
+### Making your API
+
+The easiest way to do this is to have a look at a similar sensor to yours.
+Typically create a class for your sensor with a constructor that defines the
+pins it is on. This constructor will create the mraa_*_context structs that are
+required to talk to the board's IO. An I2c sensor will create a
+mraa_i2c_context, keep it as a private member and require a bus number and slave
+address in it's constructor.
+
+Typically in sensors a simple object->read() function is prefered, depending on
+your sensor/actuaotr this may or may not be easy or not even make sense. Most
+UPM apis have a simple set of functions.
+
+### Mapping arduino API to libmraa
+
+Your constructor is similar to the setup() function in arduino, you should
+initialise your IO the way you want it. This means initialising contexts
+(private members) and setting the correct modes for them.
+
+See the mraa API documentation for exact API.
+
+### Building
+
+To build your module just follow @ref building. By creating a folder and the
+CMakelists.txt file you have done all that is required to add your sensor to
+the UPM build system.
+
+### Sending your module to us for inclusion in UPM
+
+The last step is when you're happy with your module and it works send us a pull
+request! We'd love to include your sensor in our repository.
+
+If you don't like github you can also send brendan.le.foll@intel.com a git
+formatted patch if your sensor. More details are on @ref contributing and on
+https://help.github.com/articles/creating-a-pull-request
+

examples/CMakeLists.txt

@@ -14,6 +14,13 @@ add_executable (oled-1308 oled-1308.cxx)
 add_executable (oled-1327 oled-1327.cxx)
 add_executable (proximity max44000.cxx)
 add_executable (accelerometer mma7455.cxx)
+add_executable (lcd st7735.cxx)
+add_executable (max31855-example max31855.cxx)
+add_executable (gy65-example gy65.cxx)
+add_executable (stepmotor-example stepmotor.cxx)
+add_executable (pulsensor-example pulsensor.cxx)
+add_executable (mic-example mic-example.cxx)
+add_executable (mpu9150-example mpu9150-example.cxx)
 
 include_directories (${PROJECT_SOURCE_DIR}/src/hmc5883l)
 include_directories (${PROJECT_SOURCE_DIR}/src/grove)
@@ -26,6 +33,13 @@ include_directories (${PROJECT_SOURCE_DIR}/src/servo)
 include_directories (${PROJECT_SOURCE_DIR}/src/hcsr04)
 include_directories (${PROJECT_SOURCE_DIR}/src/max44000)
 include_directories (${PROJECT_SOURCE_DIR}/src/mma7455)
+include_directories (${PROJECT_SOURCE_DIR}/src/st7735)
+include_directories (${PROJECT_SOURCE_DIR}/src/max31855)
+include_directories (${PROJECT_SOURCE_DIR}/src/gy65)
+include_directories (${PROJECT_SOURCE_DIR}/src/stepmotor)
+include_directories (${PROJECT_SOURCE_DIR}/src/pulsensor)
+include_directories (${PROJECT_SOURCE_DIR}/src/mic)
+include_directories (${PROJECT_SOURCE_DIR}/src/mpu9150)
 
 target_link_libraries (compass hmc5883l ${CMAKE_THREAD_LIBS_INIT})
 target_link_libraries (groveled grove ${CMAKE_THREAD_LIBS_INIT})
@@ -43,3 +57,10 @@ target_link_libraries (oled-1308 i2clcd ${CMAKE_THREAD_LIBS_INIT})
 target_link_libraries (oled-1327 i2clcd ${CMAKE_THREAD_LIBS_INIT})
 target_link_libraries (proximity max44000 ${CMAKE_THREAD_LIBS_INIT})
 target_link_libraries (accelerometer mma7455 ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries (lcd st7735 ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries (max31855-example max31855 ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries (gy65-example gy65 ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries (stepmotor-example stepmotor ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries (pulsensor-example pulsensor ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries (mic-example mic ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries (mpu9150-example mpu9150 ${CMAKE_THREAD_LIBS_INIT})

examples/buzzer-sound.cxx

@@ -25,20 +25,8 @@
 #include <unistd.h>
 #include <iostream>
 #include <signal.h>
-
 #include "buzzer.h"
 
-int running = 0;
-
-void
-sig_handler(int signo)
-{
-    printf("got signal\n");
-    if (signo == SIGINT) {
-        printf("exiting application\n");
-        running = 1;
-    }
-}
 
 int
 main(int argc, char **argv) {
@@ -51,13 +39,10 @@ main(int argc, char **argv) {
     std::cout << sound->name() << std::endl;
     // play sound (DO, RE, ME, etc...)
 
-    signal(SIGINT, sig_handler);
-
-    while (!running) {
-        for (int chord_ind = 0; chord_ind < 9; chord_ind++) {
-            std::cout << sound->playSound(chord[chord_ind]) << std::endl;
-            usleep(1000);
-        }
+    for (int chord_ind = 0; chord_ind < 7; chord_ind++) {
+        // play one second for each chord
+        std::cout << sound->playSound(chord[chord_ind], 1000000) << std::endl;
+        usleep(100000);
     }
     //! [Interesting]
 

examples/es08a.cxx

@@ -28,40 +28,19 @@
 #include <signal.h>
 #include <stdlib.h>
 
-int running = 0;
-
-void
-sig_handler(int signo)
-{
-    printf("got signal\n");
-    if (signo == SIGINT) {
-        printf("exiting application\n");
-        running = 1;
-    }
-}
-
 int
 main(int argc, char **argv)
 {
     //! [Interesting]
-    upm::ES08A *servo = new upm::ES08A(5);
-
-    signal(SIGINT, sig_handler);
-
-    int clock = 0;
-    while (!running) {
-        for (int i = 0; i < 18; i++) {
-            servo->setAngle (clock);
-            clock += 10;
-        }
-
-        for (int i = 0; i < 18; i++) {
-            servo->setAngle (clock);
-            clock -= 10;
-        }
-    }
+    upm::ES08A *servo = new upm::ES08A(5);    
+    servo->setAngle (180);
     //! [Interesting]
 
+    servo->setAngle (90);
+    servo->setAngle (0);
+    servo->setAngle (90);
+    servo->setAngle (180);
+
     std::cout << "exiting application" << std::endl;
 
     delete servo;

examples/gy65.cxx

@@ -0,0 +1,77 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <unistd.h>
+#include <iostream>
+#include "gy65.h"
+#include <signal.h>
+
+int doWork = 0;
+upm::GY65 *sensor = NULL;
+
+void
+sig_handler(int signo)
+{
+    printf("got signal\n");
+    if (signo == SIGINT) {
+        printf("exiting application\n");
+        doWork = 1;
+    }
+}
+
+int
+main(int argc, char **argv)
+{
+    //! [Interesting]
+    uint32_t presure = 0;
+    float temperature = 0;
+    float altitude = 0;
+    uint32_t sealevel = 0;
+
+    sensor = new upm::GY65(0, ADDR);
+
+    while (!doWork) {
+        presure = sensor->getPressure ();
+        temperature = sensor->getTemperature ();
+        altitude = sensor->getAltitude ();
+        sealevel = sensor->getSealevelPressure ();
+
+        std::cout << "pressure value = " <<
+                    presure <<
+                    ", atitude value = " <<
+                    altitude <<
+                    ", sealevel value = " <<
+                    sealevel <<
+                    ", temperature = " <<
+                    temperature << std::endl;
+        usleep (100000);
+    }
+    //! [Interesting]
+
+    std::cout << "exiting application" << std::endl;
+
+    delete sensor;
+
+    return 0;
+}

examples/hcsr04.cxx

@@ -43,7 +43,7 @@ sig_handler(int signo)
 
 //! [Interesting]
 void
-interrupt (void) {
+interrupt (void * args) {
     sonar->ackEdgeDetected ();
 }
 

examples/max31855.cxx

@@ -0,0 +1,41 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <unistd.h>
+#include <iostream>
+#include <signal.h>
+
+//! [Interesting]
+#include "max31855.h"
+
+int
+main(int argc, char **argv)
+{
+    upm::MAX31855 *temp = new upm::MAX31855(0, 8);
+
+    std::cout << temp->getTemp() << std::endl;
+
+    return 0;
+}
+//! [Interesting]

examples/mic-example.cxx

@@ -0,0 +1,74 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <unistd.h>
+#include <iostream>
+#include "mic.h"
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+int is_running = 0;
+uint16_t buffer [128];
+upm::Microphone *sensor = NULL;
+
+void
+sig_handler(int signo)
+{
+    printf("got signal\n");
+    if (signo == SIGINT) {
+        is_running = 1;
+    }
+}
+
+//! [Interesting]
+int
+main(int argc, char **argv)
+{
+    sensor = new upm::Microphone(0);
+    signal(SIGINT, sig_handler);
+
+    thresholdContext ctx;
+    ctx.averageReading = 0;
+    ctx.runningAverage = 0;
+    ctx.averagedOver   = 2;
+
+    while (!is_running) {
+        int len = sensor->getSampledWindow (2, 128, buffer);
+        if (len) {
+            int thresh = sensor->findThreshold (&ctx, 30, buffer, len);
+            sensor->printGraph(&ctx);
+            if (thresh) {
+                // do something ....
+            }
+        }
+    }
+
+    std::cout << "exiting application" << std::endl;
+
+    delete sensor;
+
+    return 0;
+}
+//! [Interesting]

examples/mpu9150-example.cxx

@@ -0,0 +1,59 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <unistd.h>
+#include <iostream>
+#include "mpu9150.h"
+
+int
+main(int argc, char **argv)
+{
+    //! [Interesting]
+    upm::Vector3D data;
+    upm::MPU9150 *sensor = new upm::MPU9150(0, ADDR);
+    sensor->getData ();
+    sensor->getAcceleromter (&data);
+    std::cout << "*************************************************" << std::endl;
+    std::cout << "DEVICE ID (" << (int) sensor->getDeviceID () << ")" << std::endl;
+    std::cout << "*************************************************" << std::endl;
+    std::cout << "ACCELEROMETER :: X (" << data.axisX << ")" << " Y (" << data.axisY << ")"
+                << " Z (" << data.axisZ << ")" << std::endl;
+
+    sensor->getGyro (&data);
+    std::cout << "GYRO :: X (" << data.axisX << ")" << " Y (" << data.axisY << ")"
+                << " Z (" << data.axisZ << ")" << std::endl;
+
+    sensor->getMagnometer (&data);
+    std::cout << "MAGNOMETER :: X (" << data.axisX << ")" << " Y (" << data.axisY << ")"
+                << " Z (" << data.axisZ << ")" << std::endl;
+    std::cout << "TEMPERATURE (" << sensor->getTemperature () << ")" << std::endl;
+    std::cout << "*************************************************" << std::endl;
+    //! [Interesting]
+
+    std::cout << "exiting application" << std::endl;
+
+    delete sensor;
+
+    return 0;
+}

examples/pulsensor.cxx

@@ -0,0 +1,61 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <string.h>
+#include <unistd.h>
+#include "pulsensor.h"
+#include <signal.h>
+
+int doWork = 0;
+pulsensor_context sensor_ctx;
+
+void
+sig_handler(int signo)
+{
+    printf("got signal\n");
+    if (signo == SIGINT) {
+        printf("exiting application\n");
+        doWork = 1;
+    }
+}
+
+void
+handler (clbk_data data) {
+    printf ("callback data (%d)\n", data);
+}
+
+int
+main(int argc, char **argv)
+{
+//! [Interesting]
+    init_pulsensor (&sensor_ctx, handler);
+    
+    start_sampler (&sensor_ctx);
+    while (!doWork) {
+        usleep (5);
+    }
+    stop_sampler (&sensor_ctx);
+//! [Interesting]
+    return 0;
+}

examples/st7735.cxx

@@ -0,0 +1,79 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <string.h>
+#include <unistd.h>
+#include <iostream>
+#include "st7735.h"
+#include <signal.h>
+
+int
+main(int argc, char **argv)
+{
+//! [Interesting]
+    upm::ST7735 * lcd = new upm::ST7735(7, 4, 9, 8);
+    lcd->fillScreen (ST7735_RED);
+    lcd->refresh ();
+
+    lcd->fillScreen (ST7735_CYAN);
+    lcd->refresh ();
+
+    lcd->fillScreen (ST7735_BLACK);
+    lcd->refresh ();
+
+    lcd->drawLine(10, 10, 10, 100, ST7735_MAGENTA);
+    lcd->drawLine(20, 20, 10, 100, ST7735_YELLOW);
+    lcd->drawLine(30, 30, 50, 100, ST7735_WHITE);
+    lcd->refresh ();
+
+    lcd->drawPixel (20, 20, ST7735_GREEN);
+    lcd->refresh ();
+
+    lcd->drawTriangle (50, 50, 80, 80, 60, 90, ST7735_GREEN);
+    lcd->refresh ();
+
+    lcd->drawCircle (100, 110, 10, ST7735_BLUE);
+    lcd->refresh ();
+
+
+    lcd->setTextWrap(0x0);
+
+    lcd->setCursor(0, 30);
+    lcd->setTextColor(ST7735_RED, ST7735_RED);
+    lcd->setTextSize(1);
+    lcd->print("Hello World!");
+
+    lcd->setCursor(10, 50);
+    lcd->setTextColor(ST7735_RED, ST7735_YELLOW);
+    lcd->setTextSize(2);
+    lcd->print("BIG");
+
+    lcd->refresh ();
+
+    std::cout << "exiting application" << std::endl;
+
+    delete lcd;
+//! [Interesting]
+    return 0;
+}

examples/stepmotor.cxx

@@ -0,0 +1,73 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <string.h>
+#include <unistd.h>
+#include <iostream>
+#include "stepmotor.h"
+#include <signal.h>
+
+int doWork = 0;
+upm::StepMotor *sensor = NULL;
+
+void
+sig_handler(int signo)
+{
+    printf("got signal\n");
+    if (signo == SIGINT) {
+        printf("exiting application\n");
+        doWork = 1;
+    }
+}
+
+int
+main(int argc, char **argv)
+{
+//! [Interesting]
+    sensor = new upm::StepMotor(4, 6);
+
+    while (!doWork) {
+        sensor->setSpeed (500);
+        sensor->stepForward (500);
+        usleep (10000);
+        sensor->stepBackwards (500);
+        usleep (10000);
+
+        sensor->setSpeed (750);
+        sensor->stepForward (500);
+        usleep (10000);
+        sensor->stepBackwards (500);
+        usleep (10000);
+
+        sensor->setSpeed (1000);
+        sensor->stepForward (500);
+        usleep (10000);
+        sensor->stepBackwards (500);
+        usleep (10000);
+    }
+
+    delete sensor;
+//! [Interesting]
+    return 0;
+}

src/CMakeLists.txt

@@ -20,7 +20,7 @@ macro(upm_SWIG_PYTHON)
     set (CMAKE_C_FLAGS -DSWIGPYTHON=${SWIG_FOUND})
     set_source_files_properties (pyupm_${libname}.i PROPERTIES CPLUSPLUS ON)
     swig_add_module (pyupm_${libname} python pyupm_${libname}.i ${module_src})
-    swig_link_libraries (pyupm_${libname} ${PYTHON_LIBRARIES} ${MAA_LIBRARIES})
+    swig_link_libraries (pyupm_${libname} ${PYTHON_LIBRARIES} ${MRAA_LIBRARIES})
     target_include_directories ( ${SWIG_MODULE_pyupm_${libname}_REAL_NAME}
       PUBLIC
       "${PYTHON_INCLUDE_PATH}"
@@ -39,7 +39,7 @@ macro(upm_SWIG_NODE)
     set_source_files_properties (jsupm_${libname}.i PROPERTIES CPLUSPLUS ON)
     set_source_files_properties (jsupm_${libname}.i PROPERTIES SWIG_FLAGS "-node")
     swig_add_module (jsupm_${libname} javascript jsupm_${libname}.i ${module_src})
-    swig_link_libraries (jsupm_${libname} ${MAA_LIBRARIES} ${NODE_LIBRARIES})
+    swig_link_libraries (jsupm_${libname} ${MRAA_LIBRARIES} ${NODE_LIBRARIES})
     target_include_directories ( ${SWIG_MODULE_jsupm_${libname}_REAL_NAME}
       PUBLIC
       "${NODE_INCLUDE_DIRS}"
@@ -95,9 +95,14 @@ endif()
 
 macro(upm_module_init)
   add_library (${libname} SHARED ${module_src})
-  include_directories (${MAA_INCLUDE_DIR} .)
-  target_link_libraries (${libname} ${MAA_LIBRARIES})
-  set_target_properties(${libname} PROPERTIES PREFIX "libupm-")
+  include_directories (${MRAA_INCLUDE_DIR} .)
+  target_link_libraries (${libname} ${MRAA_LIBRARIES})
+  set_target_properties(
+    ${libname}
+    PROPERTIES PREFIX "libupm-"
+    SOVERSION ${upm_VERSION_MAJOR}
+    VERSION ${upm_VERSION_STRING}
+  )
   upm_create_install_pkgconfig (upm-${libname}.pc lib${LIB_SUFFIX}/pkgconfig)
   if (SWIG_FOUND)
     upm_swig_python()

src/buzzer/buzzer.cxx

@@ -30,22 +30,22 @@
 using namespace upm;
 
 Buzzer::Buzzer (int pinNumber) {
-    m_pwm_context = maa_pwm_init (pinNumber);
+    m_pwm_context = mraa_pwm_init (pinNumber);
     m_name = "Buzzer";
 }
 
-int Buzzer::playSound (int note) {
-    maa_pwm_enable (m_pwm_context, 1);
-    maa_pwm_period_us (m_pwm_context, note);
-    maa_pwm_write (m_pwm_context, 50.0);
-    usleep (10000);
-    maa_pwm_enable (m_pwm_context, 0);
+int Buzzer::playSound (int note, int delay) {
+    mraa_pwm_enable (m_pwm_context, 1);
+    mraa_pwm_period_us (m_pwm_context, note);
+    mraa_pwm_pulsewidth_us (m_pwm_context, note / 2);
+    usleep (delay);
+    mraa_pwm_enable (m_pwm_context, 0);
 
-    return 0;
+    return note;
 }
 
 Buzzer::~Buzzer() {
-    maa_pwm_close(m_pwm_context);
-    std::cout << "executed maa_pwm_close" << std::endl;
+    mraa_pwm_close(m_pwm_context);
+    std::cout << "executed mraa_pwm_close" << std::endl;
 }
 

src/buzzer/buzzer.h

@@ -24,15 +24,15 @@
 #pragma once
 
 #include <string>
-#include <maa/pwm.h>
+#include <mraa/pwm.h>
 
-#define  DO     3830000    // 261 Hz
-#define  RE     3400000    // 294 Hz
-#define  MI     3038000    // 329 Hz
-#define  FA     2864000    // 349 Hz
-#define  SOL    2550000    // 392 Hz
-#define  LA     2272000    // 440 Hz
-#define  SI     2028000    // 493 Hz
+#define  DO     3300    // 261 Hz 3830
+#define  RE     2930    // 294 Hz
+#define  MI     2600    // 329 Hz
+#define  FA     2460    // 349 Hz
+#define  SOL    2190    // 392 Hz
+#define  LA     1960    // 440 Hz
+#define  SI     1750    // 493 Hz
 
 namespace upm {
 
@@ -41,7 +41,7 @@ namespace upm {
  *
  * This file defines the Buzzer C++ interface for libbuzzer
  *
- * @snippet es08a.cxx Interesting
+ * @snippet buzzer-sound.cxx Interesting
  *
  */
 class Buzzer {
@@ -62,8 +62,9 @@ class Buzzer {
          * Play chords.
          *
          * @param note chords (DO, RE, ME, etc...)
+         * @param delay time in microsec for playing the sound
          */
-        int playSound (int note);
+        int playSound (int note, int delay);
 
         /**
          * Return name of the component
@@ -75,6 +76,6 @@ class Buzzer {
     protected:
         std::string m_name;
     private:
-        maa_pwm_context m_pwm_context;
+        mraa_pwm_context m_pwm_context;
 };
 }

src/grove/grove.cxx

@@ -33,31 +33,31 @@ using namespace upm;
 
 GroveLed::GroveLed(int pin)
 {
-    maa_init();
-    m_gpio = maa_gpio_init(pin);
-    maa_gpio_dir(m_gpio, MAA_GPIO_OUT);
+    mraa_init();
+    m_gpio = mraa_gpio_init(pin);
+    mraa_gpio_dir(m_gpio, MRAA_GPIO_OUT);
     m_name = "LED Socket";
 }
 
 GroveLed::~GroveLed()
 {
-    maa_gpio_close(m_gpio);
+    mraa_gpio_close(m_gpio);
 }
 
-maa_result_t GroveLed::write(int value)
+mraa_result_t GroveLed::write(int value)
 {
     if (value >= 1) {
-        return maa_gpio_write(m_gpio, 1);
+        return mraa_gpio_write(m_gpio, 1);
     }
-    return maa_gpio_write(m_gpio, 0);
+    return mraa_gpio_write(m_gpio, 0);
 }
 
-maa_result_t GroveLed::on()
+mraa_result_t GroveLed::on()
 {
     return write(1);
 }
 
-maa_result_t GroveLed::off()
+mraa_result_t GroveLed::off()
 {
     return write(0);
 }
@@ -66,19 +66,19 @@ maa_result_t GroveLed::off()
 
 GroveTemp::GroveTemp(unsigned int pin)
 {
-    maa_init();
-    m_aio = maa_aio_init(pin);
+    mraa_init();
+    m_aio = mraa_aio_init(pin);
     m_name = "Temperature Sensor";
 }
 
 GroveTemp::~GroveTemp()
 {
-    maa_aio_close(m_aio);
+    mraa_aio_close(m_aio);
 }
 
 int GroveTemp::value ()
 {
-    int a = maa_aio_read(m_aio);
+    int a = mraa_aio_read(m_aio);
     float r = (float)(1023-a)*10000/a;
     float t = 1/(logf(r/10000)/3975 + 1/298.15)-273.15;
     return (int) t;
@@ -86,32 +86,32 @@ int GroveTemp::value ()
 
 float GroveTemp::raw_value()
 {
-    return (float) maa_aio_read(m_aio);
+    return (float) mraa_aio_read(m_aio);
 }
 
 //// GroveLight ////
 
 GroveLight::GroveLight(unsigned int pin)
 {
-    maa_init();
-    m_aio = maa_aio_init(pin);
+    mraa_init();
+    m_aio = mraa_aio_init(pin);
     m_name = "Light Sensor";
 }
 
 GroveLight::~GroveLight()
 {
-    maa_aio_close(m_aio);
+    mraa_aio_close(m_aio);
 }
 
 int GroveLight::value ()
 {
     // rough conversion to Lux
-    int a = maa_aio_read(m_aio);
+    int a = mraa_aio_read(m_aio);
     a = 10000/(((1023-a)*10/a)*15)^(4/3);
     return a;
 }
 
 float GroveLight::raw_value()
 {
-    return (float) maa_aio_read(m_aio);
+    return (float) mraa_aio_read(m_aio);
 }

src/grove/grove.h

@@ -24,8 +24,8 @@
 #pragma once
 
 #include <string>
-#include <maa/aio.h>
-#include <maa/gpio.h>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
 
 namespace upm {
 
@@ -44,11 +44,11 @@ class GroveLed: public Grove {
     public:
         GroveLed(int pin);
         ~GroveLed();
-        maa_result_t write(int value);
-        maa_result_t off();
-        maa_result_t on();
+        mraa_result_t write(int value);
+        mraa_result_t off();
+        mraa_result_t on();
     private:
-        maa_gpio_context m_gpio;
+        mraa_gpio_context m_gpio;
 };
 
 class GroveTemp: public Grove {
@@ -58,7 +58,7 @@ class GroveTemp: public Grove {
         float raw_value();
         int value();
     private:
-        maa_aio_context m_aio;
+        mraa_aio_context m_aio;
 };
 
 class GroveLight: public Grove {
@@ -68,7 +68,7 @@ class GroveLight: public Grove {
         float raw_value();
         int value();
     private:
-        maa_aio_context m_aio;
+        mraa_aio_context m_aio;
 };
 
 }

src/gy65/CMakeLists.txt

@@ -0,0 +1,5 @@
+set (libname "gy65")
+set (libdescription "upm GY65")
+set (module_src ${libname}.cxx)
+set (module_h ${libname}.h)
+upm_module_init()

src/gy65/gy65.cxx

@@ -0,0 +1,222 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <iostream>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "gy65.h"
+
+using namespace upm;
+
+GY65::GY65 (int bus, int devAddr, uint8_t mode) {
+    m_name = "GY65";
+
+    m_controlAddr = devAddr;
+    m_bus = bus;
+
+    m_i2ControlCtx = mraa_i2c_init(m_bus);
+
+    mraa_result_t ret = mraa_i2c_address(m_i2ControlCtx, m_controlAddr);
+    if (ret != MRAA_SUCCESS) {
+        fprintf(stderr, "Messed up i2c bus\n");
+    }
+
+    if (i2cReadReg_8 (0xD0) != 0x55)  {
+        std::cout << "Error :: Cannot continue" << std::endl;
+        return;
+    }
+
+    if (mode > BMP085_ULTRAHIGHRES) {
+        mode = BMP085_ULTRAHIGHRES;
+    }
+    oversampling = mode;
+
+    /* read calibration data */
+    ac1 = i2cReadReg_16 (BMP085_CAL_AC1);
+    ac2 = i2cReadReg_16 (BMP085_CAL_AC2);
+    ac3 = i2cReadReg_16 (BMP085_CAL_AC3);
+    ac4 = i2cReadReg_16 (BMP085_CAL_AC4);
+    ac5 = i2cReadReg_16 (BMP085_CAL_AC5);
+    ac6 = i2cReadReg_16 (BMP085_CAL_AC6);
+
+    b1 = i2cReadReg_16 (BMP085_CAL_B1);
+    b2 = i2cReadReg_16 (BMP085_CAL_B2);
+
+    mb = i2cReadReg_16 (BMP085_CAL_MB);
+    mc = i2cReadReg_16 (BMP085_CAL_MC);
+    md = i2cReadReg_16 (BMP085_CAL_MD);
+}
+
+GY65::~GY65() {
+    mraa_i2c_stop(m_i2ControlCtx);
+}
+
+int32_t
+GY65::getPressure () {
+    int32_t UT, UP, B3, B5, B6, X1, X2, X3, p;
+    uint32_t B4, B7;
+
+    UT = getTemperatureRaw();
+    UP = getPressureRaw();
+    B5 = computeB5(UT);
+
+    // do pressure calcs
+    B6 = B5 - 4000;
+    X1 = ((int32_t)b2 * ( (B6 * B6)>>12 )) >> 11;
+    X2 = ((int32_t)ac2 * B6) >> 11;
+    X3 = X1 + X2;
+    B3 = ((((int32_t)ac1*4 + X3) << oversampling) + 2) / 4;
+
+    X1 = ((int32_t)ac3 * B6) >> 13;
+    X2 = ((int32_t)b1 * ((B6 * B6) >> 12)) >> 16;
+    X3 = ((X1 + X2) + 2) >> 2;
+    B4 = ((uint32_t)ac4 * (uint32_t)(X3 + 32768)) >> 15;
+    B7 = ((uint32_t)UP - B3) * (uint32_t)( 50000UL >> oversampling );
+
+    if (B7 < 0x80000000) {
+        p = (B7 * 2) / B4;
+    } else {
+        p = (B7 / B4) * 2;
+    }
+    X1 = (p >> 8) * (p >> 8);
+    X1 = (X1 * 3038) >> 16;
+    X2 = (-7357 * p) >> 16;
+
+    p = p + ((X1 + X2 + (int32_t)3791)>>4);
+
+    return p;
+}
+
+int32_t
+GY65::getPressureRaw () {
+    uint32_t raw;
+
+    i2cWriteReg (BMP085_CONTROL, BMP085_READPRESSURECMD + (oversampling << 6));
+
+    if (oversampling == BMP085_ULTRALOWPOWER) {
+        usleep(5000);
+    } else if (oversampling == BMP085_STANDARD) {
+        usleep(8000);
+    } else if (oversampling == BMP085_HIGHRES) {
+        usleep(14000);
+    } else {
+        usleep(26000);
+    }
+
+    raw = i2cReadReg_16 (BMP085_PRESSUREDATA);
+
+    raw <<= 8;
+    raw |= i2cReadReg_8 (BMP085_PRESSUREDATA + 2);
+    raw >>= (8 - oversampling);
+
+    return raw;
+}
+
+int16_t
+GY65::getTemperatureRaw () {
+    i2cWriteReg (BMP085_CONTROL, BMP085_READTEMPCMD);
+    usleep(5000);
+    return i2cReadReg_16 (BMP085_TEMPDATA);
+}
+
+float
+GY65::getTemperature () {
+    int32_t UT, B5;     // following ds convention
+    float temp;
+
+    UT = getTemperatureRaw ();
+
+    B5 = computeB5 (UT);
+    temp = (B5 + 8) >> 4;
+    temp /= 10;
+
+    return temp;
+}
+
+int32_t
+GY65::getSealevelPressure(float altitudeMeters) {
+    float pressure = getPressure ();
+    return (int32_t)(pressure / pow(1.0-altitudeMeters/44330, 5.255));
+}
+
+float
+GY65::getAltitude (float sealevelPressure) {
+    float altitude;
+
+    float pressure = getPressure ();
+
+    altitude = 44330 * (1.0 - pow(pressure /sealevelPressure,0.1903));
+
+    return altitude;
+}
+
+int32_t
+GY65::computeB5(int32_t UT) {
+    int32_t X1 = (UT - (int32_t)ac6) * ((int32_t)ac5) >> 15;
+    int32_t X2 = ((int32_t)mc << 11) / (X1+(int32_t)md);
+
+    return X1 + X2;
+}
+
+mraa_result_t
+GY65::i2cWriteReg (uint8_t reg, uint8_t value) {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    uint8_t data[2] = { reg, value };
+    error = mraa_i2c_address (m_i2ControlCtx, m_controlAddr);
+    error = mraa_i2c_write (m_i2ControlCtx, data, 2);
+
+    return error;
+}
+
+uint16_t
+GY65::i2cReadReg_16 (int reg) {
+    uint16_t data;
+
+    mraa_i2c_address(m_i2ControlCtx, m_controlAddr);
+    mraa_i2c_write_byte(m_i2ControlCtx, reg);
+
+    mraa_i2c_address(m_i2ControlCtx, m_controlAddr);
+    mraa_i2c_read(m_i2ControlCtx, (uint8_t *)&data, 0x2);
+
+    uint8_t high = (data & 0xFF00) >> 8;
+    data = (data << 8) & 0xFF00;
+    data |= high;
+
+    return data;
+}
+
+uint8_t
+GY65::i2cReadReg_8 (int reg) {
+    uint8_t data;
+
+    mraa_i2c_address(m_i2ControlCtx, m_controlAddr);
+    mraa_i2c_write_byte(m_i2ControlCtx, reg);
+
+    mraa_i2c_address(m_i2ControlCtx, m_controlAddr);
+    mraa_i2c_read(m_i2ControlCtx, &data, 0x1);
+
+    return data;
+}

src/gy65/gy65.h

@@ -0,0 +1,161 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Credits to Adafruit.
+ * Based on Adafruit BMP085 library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <mraa/i2c.h>
+#include <math.h>
+
+#define ADDR               0x77 // device address
+
+// registers address
+#define BMP085_ULTRALOWPOWER 0
+#define BMP085_STANDARD      1
+#define BMP085_HIGHRES       2
+#define BMP085_ULTRAHIGHRES  3
+#define BMP085_CAL_AC1           0xAA  // R   Calibration data (16 bits)
+#define BMP085_CAL_AC2           0xAC  // R   Calibration data (16 bits)
+#define BMP085_CAL_AC3           0xAE  // R   Calibration data (16 bits)
+#define BMP085_CAL_AC4           0xB0  // R   Calibration data (16 bits)
+#define BMP085_CAL_AC5           0xB2  // R   Calibration data (16 bits)
+#define BMP085_CAL_AC6           0xB4  // R   Calibration data (16 bits)
+#define BMP085_CAL_B1            0xB6  // R   Calibration data (16 bits)
+#define BMP085_CAL_B2            0xB8  // R   Calibration data (16 bits)
+#define BMP085_CAL_MB            0xBA  // R   Calibration data (16 bits)
+#define BMP085_CAL_MC            0xBC  // R   Calibration data (16 bits)
+#define BMP085_CAL_MD            0xBE  // R   Calibration data (16 bits)
+
+#define BMP085_CONTROL           0xF4
+#define BMP085_TEMPDATA          0xF6
+#define BMP085_PRESSUREDATA      0xF6
+#define BMP085_READTEMPCMD       0x2E
+#define BMP085_READPRESSURECMD   0x34
+
+#define HIGH               1
+#define LOW                0
+
+namespace upm {
+
+/**
+ * @brief C++ API for GY65 chip (Atmospheric Pressure Sensor)
+ *
+ * This file defines the gy65 C++ interface for libgy65
+ *
+ * @snippet gy65.cxx Interesting
+ */
+class GY65 {
+    public:
+        /**
+         * Instanciates a GY65 object
+         *
+         * @param bus number of used bus
+         * @param devAddr addres of used i2c device
+         */
+        GY65 (int bus, int devAddr, uint8_t mode = BMP085_ULTRAHIGHRES);
+
+        /**
+         * GY65 object destructor, basicaly it close i2c connection.
+         */
+        ~GY65 ();
+
+        /**
+         * Return calculated pressure
+         */
+        int32_t getPressure ();
+
+        /**
+         *
+         * Get raw pressure data
+         */
+        int32_t getPressureRaw ();
+
+        /**
+         * Get raw temperature data from chip
+         */
+        int16_t getTemperatureRaw ();
+
+        /**
+         * Return calculated temperature
+         */
+        float getTemperature ();
+
+        /**
+         * With given absolute altitude sea level can be calculated
+         *
+         * @param altitudeMeters altitude
+         */
+        int32_t getSealevelPressure(float altitudeMeters = 0);
+
+        /**
+         * With given sea level altitude in meters can be calculated
+         *
+         * @param sealevelPressure Sea level
+         */
+        float getAltitude (float sealevelPressure = 101325);
+
+        /**
+         * Calculation of B5 (check spec for more information)
+         *
+         * @param UT
+         */
+        int32_t computeB5 (int32_t UT);
+
+        /**
+         * Read two bytes register
+         *
+         * @param reg address of a register
+         */
+        uint16_t i2cReadReg_16 (int reg);
+
+        /**
+         * Write to one byte register
+         *
+         * @param reg address of a register
+         * @param value byte to be written
+         */
+        mraa_result_t i2cWriteReg (uint8_t reg, uint8_t value);
+
+        /**
+         * Read one byte register
+         *
+         * @param reg address of a register
+         */
+        uint8_t i2cReadReg_8 (int reg);
+
+    private:
+        std::string m_name;
+
+        int m_controlAddr;
+        int m_bus;
+        mraa_i2c_context m_i2ControlCtx;
+
+        uint8_t oversampling;
+        int16_t ac1, ac2, ac3, b1, b2, mb, mc, md;
+        uint16_t ac4, ac5, ac6;
+};
+
+}

src/gy65/jsupm_gy65.i

@@ -0,0 +1,7 @@
+%module jsupm_gy65
+
+%{
+    #include "gy65.h"
+%}
+
+%include "gy65.h"

src/gy65/pyupm_gy65.i

@@ -0,0 +1,10 @@
+%module pyupm_gy65
+
+%include "stdint.i"
+
+%feature("autodoc", "3");
+
+%include "gy65.h"
+%{
+    #include "gy65.h"
+%}

src/hcsr04/hcsr04.cxx

@@ -31,44 +31,44 @@
 
 using namespace upm;
 
-HCSR04::HCSR04 (uint8_t triggerPin, uint8_t echoPin, void (*fptr)(void)) {
-    maa_result_t error  = MAA_SUCCESS;
+HCSR04::HCSR04 (uint8_t triggerPin, uint8_t echoPin, void (*fptr)(void *)) {
+    mraa_result_t error  = MRAA_SUCCESS;
     m_name              = "HCSR04";
 
-    m_pwmTriggerCtx     = maa_pwm_init (triggerPin);
+    m_pwmTriggerCtx     = mraa_pwm_init (triggerPin);
     if (m_pwmTriggerCtx == NULL) {
         std::cout << "PWM context is NULL" << std::endl;
         exit (1);
     }
 
-    maa_init();
-    m_echoPinCtx = maa_gpio_init(echoPin);
+    mraa_init();
+    m_echoPinCtx = mraa_gpio_init(echoPin);
     if (m_echoPinCtx == NULL) {
         fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", echoPin);
         exit (1);
     }
 
-    maa_gpio_dir(m_echoPinCtx, MAA_GPIO_IN);
-    gpio_edge_t edge = MAA_GPIO_EDGE_BOTH;
-    maa_gpio_isr (m_echoPinCtx, edge, fptr);
+    mraa_gpio_dir(m_echoPinCtx, MRAA_GPIO_IN);
+    gpio_edge_t edge = MRAA_GPIO_EDGE_BOTH;
+    mraa_gpio_isr (m_echoPinCtx, edge, fptr, NULL);
 }
 
 HCSR04::~HCSR04 () {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
-    maa_pwm_close (m_pwmTriggerCtx);
-    error = maa_gpio_close (m_echoPinCtx);
-    if (error != MAA_SUCCESS) {
-        maa_result_print (error);
+    mraa_pwm_close (m_pwmTriggerCtx);
+    error = mraa_gpio_close (m_echoPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
     }
 }
 
 int
 HCSR04::getDistance () {
-    maa_pwm_enable (m_pwmTriggerCtx, 1);
-    maa_pwm_period_us (m_pwmTriggerCtx, MAX_PERIOD);
-    maa_pwm_pulsewidth_us (m_pwmTriggerCtx, TRIGGER_PULSE);
-    maa_pwm_enable (m_pwmTriggerCtx, 0);
+    mraa_pwm_enable (m_pwmTriggerCtx, 1);
+    mraa_pwm_period_us (m_pwmTriggerCtx, MAX_PERIOD);
+    mraa_pwm_pulsewidth_us (m_pwmTriggerCtx, TRIGGER_PULSE);
+    mraa_pwm_enable (m_pwmTriggerCtx, 0);
 
     m_doWork = 0;
     m_InterruptCounter = 0;

src/hcsr04/hcsr04.h

@@ -24,9 +24,9 @@
 #pragma once
 
 #include <string>
-#include <maa/aio.h>
-#include <maa/gpio.h>
-#include <maa/pwm.h>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
+#include <mraa/pwm.h>
 #include <sys/time.h>
 
 #define HIGH                   1
@@ -55,7 +55,7 @@ class HCSR04 {
          * @param fptr function pointer for handling raising and
          * falling interrupts
          */
-        HCSR04 (uint8_t triggerPin, uint8_t echoPin, void (*fptr)(void));
+        HCSR04 (uint8_t triggerPin, uint8_t echoPin, void (*fptr)(void *));
 
         /**
          * HCSR04 object destructor.
@@ -85,8 +85,8 @@ class HCSR04 {
         }
 
     private:
-        maa_pwm_context     m_pwmTriggerCtx;
-        maa_gpio_context    m_echoPinCtx;
+        mraa_pwm_context     m_pwmTriggerCtx;
+        mraa_gpio_context    m_echoPinCtx;
 
         uint8_t m_waitEcho;
         long    m_RisingTimeStamp;

src/hmc5883l/hmc5883l.cxx

@@ -79,17 +79,17 @@ using namespace upm;
 
 Hmc5883l::Hmc5883l(int bus)
 {
-    m_i2c = maa_i2c_init(bus);
+    m_i2c = mraa_i2c_init(bus);
 
-    maa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
+    mraa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
     m_rx_tx_buf[0] = HMC5883L_CONF_REG_B;
     m_rx_tx_buf[1] = GA_1_3_REG;
-    maa_i2c_write(m_i2c, m_rx_tx_buf, 2);
+    mraa_i2c_write(m_i2c, m_rx_tx_buf, 2);
 
-    maa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
+    mraa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
     m_rx_tx_buf[0] = HMC5883L_MODE_REG;
     m_rx_tx_buf[1] = HMC5883L_CONT_MODE;
-    maa_i2c_write(m_i2c, m_rx_tx_buf, 2);
+    mraa_i2c_write(m_i2c, m_rx_tx_buf, 2);
 
     Hmc5883l::update();
 }
@@ -97,11 +97,11 @@ Hmc5883l::Hmc5883l(int bus)
 int
 Hmc5883l::update(void)
 {
-    maa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
-    maa_i2c_write_byte(m_i2c, HMC5883L_DATA_REG);
+    mraa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
+    mraa_i2c_write_byte(m_i2c, HMC5883L_DATA_REG);
 
-    maa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
-    maa_i2c_read(m_i2c, m_rx_tx_buf, DATA_REG_SIZE);
+    mraa_i2c_address(m_i2c, HMC5883L_I2C_ADDR);
+    mraa_i2c_read(m_i2c, m_rx_tx_buf, DATA_REG_SIZE);
 
     // x
     m_coor[0] = (m_rx_tx_buf[HMC5883L_X_MSB_REG] << 8 ) | m_rx_tx_buf[HMC5883L_X_LSB_REG];
@@ -110,7 +110,7 @@ Hmc5883l::update(void)
     // y
     m_coor[1] = (m_rx_tx_buf[HMC5883L_Y_MSB_REG] << 8 ) | m_rx_tx_buf[HMC5883L_Y_LSB_REG];
 
-    return MAA_SUCCESS;
+    return MRAA_SUCCESS;
 }
 
 float

src/hmc5883l/hmc5883l.h

@@ -23,7 +23,7 @@
  */
 #pragma once
 
-#include <maa/i2c.h>
+#include <mraa/i2c.h>
 
 #define MAX_BUFFER_LENGTH 6
 
@@ -55,7 +55,7 @@ public:
 private:
     int m_coor[3];
     uint8_t m_rx_tx_buf[MAX_BUFFER_LENGTH];
-    maa_i2c_context m_i2c;
+    mraa_i2c_context m_i2c;
 };
 
 }

src/lcd/i2clcd.cxx

@@ -33,54 +33,54 @@ I2CLcd::I2CLcd (int bus, int lcdAddress) {
     m_lcd_control_address = lcdAddress;
     m_bus = bus;
 
-    m_i2c_lcd_control = maa_i2c_init(m_bus);
+    m_i2c_lcd_control = mraa_i2c_init(m_bus);
 
-    maa_result_t ret = maa_i2c_address(m_i2c_lcd_control, m_lcd_control_address);
-    if (ret != MAA_SUCCESS) {
+    mraa_result_t ret = mraa_i2c_address(m_i2c_lcd_control, m_lcd_control_address);
+    if (ret != MRAA_SUCCESS) {
         fprintf(stderr, "Messed up i2c bus\n");
     }
 }
 
-maa_result_t
+mraa_result_t
 I2CLcd::write (int row, int column, std::string msg) {
     setCursor (row, column);
     write (msg);
 }
 
-maa_result_t
+mraa_result_t
 I2CLcd::close() {
-    return maa_i2c_stop(m_i2c_lcd_control);
+    return mraa_i2c_stop(m_i2c_lcd_control);
 }
 
-maa_result_t
-I2CLcd::i2cReg (maa_i2c_context ctx, int deviceAdress, int addr, uint8_t value) {
-    maa_result_t error = MAA_SUCCESS;
+mraa_result_t
+I2CLcd::i2cReg (mraa_i2c_context ctx, int deviceAdress, int addr, uint8_t value) {
+    mraa_result_t error = MRAA_SUCCESS;
 
     uint8_t data[2] = { addr, value };
-    error = maa_i2c_address (ctx, deviceAdress);
-    error = maa_i2c_write (ctx, data, 2);
+    error = mraa_i2c_address (ctx, deviceAdress);
+    error = mraa_i2c_write (ctx, data, 2);
 
     return error;
 }
 
-maa_result_t
-I2CLcd::i2Cmd (maa_i2c_context ctx, uint8_t value) {
-    maa_result_t error = MAA_SUCCESS;
+mraa_result_t
+I2CLcd::i2Cmd (mraa_i2c_context ctx, uint8_t value) {
+    mraa_result_t error = MRAA_SUCCESS;
 
     uint8_t data[2] = { LCD_CMD, value };
-    error = maa_i2c_address (ctx, m_lcd_control_address);
-    error = maa_i2c_write (ctx, data, 2);
+    error = mraa_i2c_address (ctx, m_lcd_control_address);
+    error = mraa_i2c_write (ctx, data, 2);
 
     return error;
 }
 
-maa_result_t
-I2CLcd::i2cData (maa_i2c_context ctx, uint8_t value) {
-    maa_result_t error = MAA_SUCCESS;
+mraa_result_t
+I2CLcd::i2cData (mraa_i2c_context ctx, uint8_t value) {
+    mraa_result_t error = MRAA_SUCCESS;
 
     uint8_t data[2] = { LCD_DATA, value };
-    error = maa_i2c_address (ctx, m_lcd_control_address);
-    error = maa_i2c_write (ctx, data, 2);
+    error = mraa_i2c_address (ctx, m_lcd_control_address);
+    error = mraa_i2c_write (ctx, data, 2);
 
     return error;
 }

src/lcd/i2clcd.h

@@ -24,7 +24,7 @@
 #pragma once
 
 #include <string>
-#include <maa/i2c.h>
+#include <mraa/i2c.h>
 
 namespace upm {
 
@@ -70,17 +70,17 @@ namespace upm {
 class I2CLcd {
     public:
         I2CLcd (int bus, int lcdAddress);
-        maa_result_t write (int x, int y, std::string msg);
+        mraa_result_t write (int x, int y, std::string msg);
         
-        virtual maa_result_t write (std::string msg) = 0;
-        virtual maa_result_t setCursor (int row, int column) = 0;
-        virtual maa_result_t clear () = 0;
-        virtual maa_result_t home () = 0;
-        virtual maa_result_t i2Cmd (maa_i2c_context ctx, uint8_t value);
-        virtual maa_result_t i2cReg (maa_i2c_context ctx, int deviceAdress, int addr, uint8_t data);
-        virtual maa_result_t i2cData (maa_i2c_context ctx, uint8_t value);
+        virtual mraa_result_t write (std::string msg) = 0;
+        virtual mraa_result_t setCursor (int row, int column) = 0;
+        virtual mraa_result_t clear () = 0;
+        virtual mraa_result_t home () = 0;
+        virtual mraa_result_t i2Cmd (mraa_i2c_context ctx, uint8_t value);
+        virtual mraa_result_t i2cReg (mraa_i2c_context ctx, int deviceAdress, int addr, uint8_t data);
+        virtual mraa_result_t i2cData (mraa_i2c_context ctx, uint8_t value);
         
-        maa_result_t close();
+        mraa_result_t close();
         std::string name()
         {
             return m_name;
@@ -89,7 +89,7 @@ class I2CLcd {
         std::string m_name;
         int m_lcd_control_address;
         int m_bus;
-        maa_i2c_context m_i2c_lcd_control;
+        mraa_i2c_context m_i2c_lcd_control;
 };
 
 }

src/lcd/jhd1313m1.cxx

@@ -30,13 +30,13 @@
 using namespace upm;
 
 Jhd1313m1::Jhd1313m1 (int bus, int lcdAddress, int rgbAddress) : I2CLcd(bus, lcdAddress) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     m_rgb_address = rgbAddress;
-    m_i2c_lcd_rgb = maa_i2c_init(m_bus);
+    m_i2c_lcd_rgb = mraa_i2c_init(m_bus);
 
-    maa_result_t ret = maa_i2c_address(m_i2c_lcd_rgb, m_rgb_address);
-    if (ret != MAA_SUCCESS) {
+    mraa_result_t ret = mraa_i2c_address(m_i2c_lcd_rgb, m_rgb_address);
+    if (ret != MRAA_SUCCESS) {
         fprintf(stderr, "Messed up i2c bus\n");
     }
 
@@ -75,9 +75,9 @@ Jhd1313m1::~Jhd1313m1() {
  *  virtual area
  * **************
  */
-maa_result_t
+mraa_result_t
 Jhd1313m1::write (std::string msg) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     uint8_t data[2] = {0x40, 0};
     for (std::string::size_type i = 0; i < msg.size(); ++i) {
         error = i2cData (m_i2c_lcd_control, msg[i]);
@@ -86,9 +86,9 @@ Jhd1313m1::write (std::string msg) {
     return error;
 }
 
-maa_result_t
+mraa_result_t
 Jhd1313m1::setCursor (int row, int column) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     int row_addr[] = { 0x80, 0xc0, 0x14, 0x54};
     uint8_t offset = ((column % 16) + row_addr[row]);
     error =  i2Cmd (m_i2c_lcd_control, offset);
@@ -96,12 +96,12 @@ Jhd1313m1::setCursor (int row, int column) {
     return error;
 }
 
-maa_result_t
+mraa_result_t
 Jhd1313m1::clear () {
     return i2Cmd (m_i2c_lcd_control, LCD_CLEARDISPLAY);
 }
 
-maa_result_t
+mraa_result_t
 Jhd1313m1::home () {
     return i2Cmd (m_i2c_lcd_control, LCD_RETURNHOME);
 }

src/lcd/jhd1313m1.h

@@ -32,14 +32,14 @@ class Jhd1313m1 : public I2CLcd {
     public:
         Jhd1313m1 (int bus, int lcdAddress, int rgbAddress);
         ~Jhd1313m1 ();
-        maa_result_t write (std::string msg);
-        maa_result_t setCursor (int row, int column);
-        maa_result_t clear ();
-        maa_result_t home ();
+        mraa_result_t write (std::string msg);
+        mraa_result_t setCursor (int row, int column);
+        mraa_result_t clear ();
+        mraa_result_t home ();
 
     private:
         int m_rgb_address;
-        maa_i2c_context m_i2c_lcd_rgb;
+        mraa_i2c_context m_i2c_lcd_rgb;
 };
 
 }

src/lcd/lcm1602.cxx

@@ -33,7 +33,7 @@
 using namespace upm;
 
 Lcm1602::Lcm1602(int bus_in, int addr_in) : I2CLcd (bus_in, addr_in) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     usleep(50000);
     expandWrite(LCD_BACKLIGHT);
@@ -69,18 +69,18 @@ Lcm1602::~Lcm1602 () {
  *  virtual area
  * **************
  */
-maa_result_t
+mraa_result_t
 Lcm1602::write (std::string msg) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     for (std::string::size_type i = 0; i < msg.size(); ++i) {
         error = send (msg[i], LCD_RS);
     }
     return error;
 }
 
-maa_result_t
+mraa_result_t
 Lcm1602::setCursor (int row, int column) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     int row_addr[] = { 0x80, 0xc0, 0x14, 0x54};
     uint8_t offset = ((column % 16) + row_addr[row]);
@@ -88,12 +88,12 @@ Lcm1602::setCursor (int row, int column) {
     return send (LCD_CMD | offset, 0);
 }
 
-maa_result_t
+mraa_result_t
 Lcm1602::clear () {
     return send(LCD_CLEARDISPLAY, 0);
 }
 
-maa_result_t
+mraa_result_t
 Lcm1602::home () {
     return send(LCD_RETURNHOME, 0);
 }
@@ -103,9 +103,9 @@ Lcm1602::home () {
  *  private area
  * **************
  */
-maa_result_t
+mraa_result_t
 Lcm1602::send (uint8_t value, int mode) {
-    maa_result_t ret = MAA_SUCCESS;
+    mraa_result_t ret = MRAA_SUCCESS;
     uint8_t h = value & 0xf0;
     uint8_t l = (value << 4) & 0xf0;
     ret = write4bits(h | mode);
@@ -113,26 +113,26 @@ Lcm1602::send (uint8_t value, int mode) {
     return ret;
 }
 
-maa_result_t
+mraa_result_t
 Lcm1602::write4bits(uint8_t value)
 {
-    maa_result_t ret = MAA_SUCCESS;
+    mraa_result_t ret = MRAA_SUCCESS;
     ret = expandWrite(value);
     ret = pulseEnable(value);
     return ret;
 }
 
-maa_result_t
+mraa_result_t
 Lcm1602::expandWrite(uint8_t value)
 {
     uint8_t buffer = value | LCD_BACKLIGHT;
-    return maa_i2c_write_byte(m_i2c_lcd_control, buffer);
+    return mraa_i2c_write_byte(m_i2c_lcd_control, buffer);
 }
 
-maa_result_t
+mraa_result_t
 Lcm1602::pulseEnable(uint8_t value)
 {
-    maa_result_t ret = MAA_SUCCESS;
+    mraa_result_t ret = MRAA_SUCCESS;
     ret = expandWrite(value | LCD_EN);
     usleep(1);
     ret = expandWrite(value & ~LCD_EN);

src/lcd/lcm1602.h

@@ -35,21 +35,21 @@ namespace upm {
 class Lcm1602 : public I2CLcd {
     public:
         /** LCM1602 Constructor.
-         * Calls MAA initialisation functions.
+         * Calls MRAA initialisation functions.
          * @param bus i2c bus to use
          * @param address the slave address the lcd is registered on.
          */
         Lcm1602(int bus, int address);
         ~Lcm1602();
-        maa_result_t write (std::string msg);
-        maa_result_t setCursor (int row, int column);
-        maa_result_t clear ();
-        maa_result_t home ();
+        mraa_result_t write (std::string msg);
+        mraa_result_t setCursor (int row, int column);
+        mraa_result_t clear ();
+        mraa_result_t home ();
 
     private :
-        maa_result_t send (uint8_t value, int mode);
-        maa_result_t write4bits(uint8_t value);
-        maa_result_t expandWrite(uint8_t value);
-        maa_result_t pulseEnable(uint8_t value);
+        mraa_result_t send (uint8_t value, int mode);
+        mraa_result_t write4bits(uint8_t value);
+        mraa_result_t expandWrite(uint8_t value);
+        mraa_result_t pulseEnable(uint8_t value);
     };
 }

src/lcd/ssd1308.cxx

@@ -45,9 +45,9 @@ SSD1308::~SSD1308 () {
 
 }
 
-maa_result_t
+mraa_result_t
 SSD1308::draw (uint8_t *data, int bytes) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     setAddressingMode (HORIZONTAL);
     for (int idx = 0; idx < bytes; idx++) {
@@ -62,9 +62,9 @@ SSD1308::draw (uint8_t *data, int bytes) {
  *  virtual area
  * **************
  */
-maa_result_t
+mraa_result_t
 SSD1308::write (std::string msg) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     uint8_t data[2] = {0x40, 0};
 
     setAddressingMode (PAGE);
@@ -75,9 +75,9 @@ SSD1308::write (std::string msg) {
     return error;
 }
 
-maa_result_t
+mraa_result_t
 SSD1308::setCursor (int row, int column) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     error = i2Cmd (m_i2c_lcd_control, BASE_PAGE_START_ADDR + row);                           // set page address
     error = i2Cmd (m_i2c_lcd_control, BASE_LOW_COLUMN_ADDR + (8 * column & 0x0F));           // set column lower address
@@ -86,9 +86,9 @@ SSD1308::setCursor (int row, int column) {
     return error;
 }
 
-maa_result_t
+mraa_result_t
 SSD1308::clear () {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     uint8_t columnIdx, rowIdx;
 
     i2Cmd (m_i2c_lcd_control, DISPLAY_CMD_OFF);  // display off
@@ -103,10 +103,10 @@ SSD1308::clear () {
     i2Cmd (m_i2c_lcd_control, DISPLAY_CMD_ON);   // display on
     home ();
 
-    return MAA_SUCCESS;
+    return MRAA_SUCCESS;
 }
 
-maa_result_t
+mraa_result_t
 SSD1308::home () {
     return setCursor (0, 0);
 }
@@ -116,8 +116,8 @@ SSD1308::home () {
  *  private area
  * **************
  */
-maa_result_t
-SSD1308::writeChar (maa_i2c_context ctx, uint8_t value) {
+mraa_result_t
+SSD1308::writeChar (mraa_i2c_context ctx, uint8_t value) {
     if (value < 0x20 || value > 0x7F) {
         value = 0x20; // space
     }
@@ -127,12 +127,12 @@ SSD1308::writeChar (maa_i2c_context ctx, uint8_t value) {
     }
 }
 
-maa_result_t
+mraa_result_t
 SSD1308::setNormalDisplay () {
     return i2Cmd (m_i2c_lcd_control, DISPLAY_CMD_SET_NORMAL);    // set to normal display '1' is ON
 }
 
-maa_result_t
+mraa_result_t
 SSD1308::setAddressingMode (displayAddressingMode mode) {
     i2Cmd (m_i2c_lcd_control, DISPLAY_CMD_MEM_ADDR_MODE); //set addressing mode
     i2Cmd (m_i2c_lcd_control, mode); //set page addressing mode

src/lcd/ssd1308.h

@@ -148,23 +148,23 @@ typedef enum {
 class SSD1308 : public I2CLcd {
     public:
         /** SSD1308 Constructor.
-         * Calls MAA initialisation functions.
+         * Calls MRAA initialisation functions.
          * @param bus i2c bus to use
          * @param address the slave address the lcd is registered on.
          */
         SSD1308 (int bus, int address);
         ~SSD1308 ();
-        maa_result_t draw(uint8_t *data, int bytes);
+        mraa_result_t draw(uint8_t *data, int bytes);
 
         // pure virtual methods
-        maa_result_t write (std::string msg);
-        maa_result_t setCursor (int row, int column);
-        maa_result_t clear ();
-        maa_result_t home ();
+        mraa_result_t write (std::string msg);
+        mraa_result_t setCursor (int row, int column);
+        mraa_result_t clear ();
+        mraa_result_t home ();
 
     private:
-        maa_result_t writeChar (maa_i2c_context ctx, uint8_t value);
-        maa_result_t setNormalDisplay ();
-        maa_result_t setAddressingMode (displayAddressingMode mode);
+        mraa_result_t writeChar (mraa_i2c_context ctx, uint8_t value);
+        mraa_result_t setNormalDisplay ();
+        mraa_result_t setAddressingMode (displayAddressingMode mode);
     };
 }

src/lcd/ssd1327.cxx

@@ -33,7 +33,7 @@ using namespace upm;
 #define CMD_SLEEP  10000
 
 SSD1327::SSD1327 (int bus_in, int addr_in) : I2CLcd (bus_in, addr_in) {
-    maa_result_t error  = MAA_SUCCESS;
+    mraa_result_t error  = MRAA_SUCCESS;
     usleep (INIT_SLEEP);
     i2Cmd (m_i2c_lcd_control, 0xFD); // Unlock OLED driver IC MCU interface from entering command. i.e: Accept commands
     usleep (INIT_SLEEP);
@@ -123,9 +123,9 @@ SSD1327::~SSD1327 () {
 
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::draw (uint8_t *data, int bytes) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     setHorizontalMode ();
     for (int row = 0; row < bytes; row++) {
@@ -151,9 +151,9 @@ SSD1327::draw (uint8_t *data, int bytes) {
  *  virtual area
  * **************
  */
-maa_result_t
+mraa_result_t
 SSD1327::write (std::string msg) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     setVerticalMode ();
     for (std::string::size_type i = 0; i < msg.size(); ++i) {
@@ -163,9 +163,9 @@ SSD1327::write (std::string msg) {
     return error;
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::setCursor (int row, int column) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     //Column Address
     i2Cmd (m_i2c_lcd_control, 0x15);                /* Set Column Address */
@@ -185,9 +185,9 @@ SSD1327::setCursor (int row, int column) {
     return error;
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::clear () {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     uint8_t columnIdx, rowIdx;
 
     for(rowIdx = 0; rowIdx < 12; rowIdx++) {
@@ -197,15 +197,15 @@ SSD1327::clear () {
         }
     }
 
-    return MAA_SUCCESS;
+    return MRAA_SUCCESS;
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::home () {
     return setCursor (0, 0);
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::setGrayLevel (uint8_t level) {
     grayHigh = (level << 4) & 0xF0;
     grayLow  =  level & 0x0F;
@@ -216,8 +216,8 @@ SSD1327::setGrayLevel (uint8_t level) {
  *  private area
  * **************
  */
-maa_result_t
-SSD1327::writeChar (maa_i2c_context ctx, uint8_t value) {
+mraa_result_t
+SSD1327::writeChar (mraa_i2c_context ctx, uint8_t value) {
     if (value < 0x20 || value > 0x7F) {
         value = 0x20; // space
     }
@@ -238,12 +238,12 @@ SSD1327::writeChar (maa_i2c_context ctx, uint8_t value) {
     }
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::setNormalDisplay () {
     return i2Cmd (m_i2c_lcd_control, DISPLAY_CMD_SET_NORMAL);    // set to normal display '1' is ON
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::setHorizontalMode () {
     i2Cmd (m_i2c_lcd_control, 0xA0); // remap to
     usleep (CMD_SLEEP);
@@ -267,7 +267,7 @@ SSD1327::setHorizontalMode () {
     usleep (CMD_SLEEP);
 }
 
-maa_result_t
+mraa_result_t
 SSD1327::setVerticalMode () {
     i2Cmd (m_i2c_lcd_control, 0xA0); // remap to
     usleep (CMD_SLEEP);

src/lcd/ssd1327.h

@@ -148,26 +148,26 @@ typedef enum {
 class SSD1327 : public I2CLcd {
     public:
         /** SSD1308 Constructor.
-         * Calls MAA initialisation functions.
+         * Calls MRAA initialisation functions.
          * @param bus i2c bus to use
          * @param address the slave address the lcd is registered on.
          */
         SSD1327 (int bus, int address);
         ~SSD1327 ();
-        maa_result_t draw(uint8_t *data, int bytes);
+        mraa_result_t draw(uint8_t *data, int bytes);
 
         // virtual methods
-        maa_result_t write (std::string msg);
-        maa_result_t setCursor (int row, int column);
-        maa_result_t clear ();
-        maa_result_t home ();
-        maa_result_t setGrayLevel (uint8_t level);
+        mraa_result_t write (std::string msg);
+        mraa_result_t setCursor (int row, int column);
+        mraa_result_t clear ();
+        mraa_result_t home ();
+        mraa_result_t setGrayLevel (uint8_t level);
 
     private:
-        maa_result_t writeChar (maa_i2c_context ctx, uint8_t value);
-        maa_result_t setNormalDisplay ();
-        maa_result_t setHorizontalMode ();
-        maa_result_t setVerticalMode ();
+        mraa_result_t writeChar (mraa_i2c_context ctx, uint8_t value);
+        mraa_result_t setNormalDisplay ();
+        mraa_result_t setHorizontalMode ();
+        mraa_result_t setVerticalMode ();
 
         uint8_t grayHigh;
         uint8_t grayLow;

src/max31855/CMakeLists.txt

@@ -0,0 +1,5 @@
+set (libname "max31855")
+set (libdescription "K type thermistor amplifier")
+set (module_src ${libname}.cxx)
+set (module_h ${libname}.h)
+upm_module_init()

src/max31855/jsupm_max31855.i

@@ -0,0 +1,9 @@
+//! [Interesting]
+%module jsupm_max31855
+
+%{
+    #include "max31855.h"
+%}
+
+%include "max31855.h"
+//! [Interesting]

src/max31855/max31855.cxx

@@ -0,0 +1,103 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <iostream>
+#include <unistd.h>
+#include <stdlib.h>
+#include <functional>
+#include <string.h>
+
+#include "max31855.h"
+
+using namespace upm;
+
+//! [Constructor]
+MAX31855::MAX31855(int bus, int cs)
+{
+    // initialise chip select as a normal gpio
+    m_gpio = mraa_gpio_init(cs);
+    mraa_gpio_dir(m_gpio, MRAA_GPIO_OUT);
+
+    // initialise the spi bus with a 2Mhz clock
+    m_sensor = mraa_spi_init(bus);
+    mraa_spi_frequency(m_sensor, 2000000);
+}
+//! [Constructor]
+
+//! [Destructor]
+MAX31855::~MAX31855()
+{
+    // close both m_sensor & m_gpio cleanly
+    mraa_result_t error;
+    error = mraa_spi_stop(m_sensor);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+    error = mraa_gpio_close(m_gpio);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+}
+//! [Destructor]
+
+double
+MAX31855::getTemp()
+{
+//! [spi]
+    // set chip select low
+    mraa_gpio_write(m_gpio, 0);
+
+    uint8_t buf[4];
+
+    // set our input buffer to 0, this is clean but not required
+    memset(buf, 0, sizeof(uint8_t)*4);
+
+    // Write buffer to the spi slave
+    uint8_t* x = mraa_spi_write_buf(m_sensor, buf, 4);
+//! [spi]
+
+//! [conversion]
+    // Endian correct way of making our char array into an 32bit int
+    int32_t temp = (x[0] << 24) | (x[1] << 16) | (x[2] << 8) | x[3];;
+
+    // mraa_spi_write_buf does not free the return buffer
+    free(x);
+
+    if (temp & 0x7) {
+        std::cerr << "Something went very wrong!" << std::endl;
+    }
+
+    // scrap all the data we dont care about
+    temp >>= 18;
+
+    // LSB = 0.25 degrees C
+    double c = (double) temp;
+    c *= 0.25;
+//! [conversion]
+
+    // set chip select high
+    mraa_gpio_write(m_gpio, 1);
+
+    return c;
+}

src/max31855/max31855.h

@@ -0,0 +1,69 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <mraa/spi.h>
+#include <mraa/gpio.h>
+
+namespace upm {
+
+/**
+ * @brief C++ API for MAX31855
+ *
+ * This file defines the max31855 SPI sensor
+ *
+ * @snippet examples/max31855.cxx Interesting
+ *
+ */
+ //! [Interesting]
+class MAX31855 {
+    public:
+        /**
+         * Instanciates a MAX31855 object
+         *
+         * @param bus The spi bus to use
+         * @param cs The chip select pin
+         */
+        MAX31855(int bus, int cs);
+
+        /**
+         * MAX31855 object destructor
+         */
+        ~MAX31855();
+
+        /**
+         * Get the distance from the sensor
+         *
+         * @return value in degrees celcius
+         */
+        double getTemp();
+
+    private:
+        mraa_spi_context m_sensor;
+        mraa_gpio_context m_gpio;
+};
+//! [Interesting]
+
+}

src/max31855/pyupm_max31855.i

@@ -0,0 +1,10 @@
+%module pyupm_max31855
+
+%include "stdint.i"
+
+%feature("autodoc", "3");
+
+%include "max31855.h"
+%{
+    #include "max31855.h"
+%}

src/max44000/max44000.cxx

@@ -36,10 +36,10 @@ MAX44000::MAX44000 (int bus, int devAddr) {
     m_maxControlAddr = devAddr;
     m_bus = bus;
 
-    m_i2cMaxControlCtx = maa_i2c_init(m_bus);
+    m_i2cMaxControlCtx = mraa_i2c_init(m_bus);
 
-    maa_result_t ret = maa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
-    if (ret != MAA_SUCCESS) {
+    mraa_result_t ret = mraa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
+    if (ret != MRAA_SUCCESS) {
         fprintf(stderr, "Messed up i2c bus\n");
     }
 
@@ -48,7 +48,7 @@ MAX44000::MAX44000 (int bus, int devAddr) {
 }
 
 MAX44000::~MAX44000() {
-    maa_i2c_stop(m_i2cMaxControlCtx);
+    mraa_i2c_stop(m_i2cMaxControlCtx);
 }
 
 uint16_t
@@ -80,11 +80,11 @@ uint8_t
 MAX44000::i2cReadReg_8 (int reg) {
     uint8_t data;
 
-    maa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
-    maa_i2c_write_byte(m_i2cMaxControlCtx, reg);
+    mraa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
+    mraa_i2c_write_byte(m_i2cMaxControlCtx, reg);
 
-    maa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
-    maa_i2c_read(m_i2cMaxControlCtx, &data, 0x1);
+    mraa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
+    mraa_i2c_read(m_i2cMaxControlCtx, &data, 0x1);
 
     return data;
 }
@@ -93,22 +93,22 @@ uint16_t
 MAX44000::i2cReadReg_16 (int reg) {
     uint16_t data;
 
-    maa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
-    maa_i2c_write_byte(m_i2cMaxControlCtx, reg);
+    mraa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
+    mraa_i2c_write_byte(m_i2cMaxControlCtx, reg);
 
-    maa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
-    maa_i2c_read(m_i2cMaxControlCtx, (uint8_t *)&data, 0x2);
+    mraa_i2c_address(m_i2cMaxControlCtx, m_maxControlAddr);
+    mraa_i2c_read(m_i2cMaxControlCtx, (uint8_t *)&data, 0x2);
 
     return data;
 }
 
-maa_result_t
+mraa_result_t
 MAX44000::i2cWriteReg (uint8_t reg, uint8_t value) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     uint8_t data[2] = { reg, value };
-    error = maa_i2c_address (m_i2cMaxControlCtx, m_maxControlAddr);
-    error = maa_i2c_write (m_i2cMaxControlCtx, data, 2);
+    error = mraa_i2c_address (m_i2cMaxControlCtx, m_maxControlAddr);
+    error = mraa_i2c_write (m_i2cMaxControlCtx, data, 2);
 
     return error;
 }

src/max44000/max44000.h

@@ -24,7 +24,7 @@
 #pragma once
 
 #include <string>
-#include <maa/i2c.h>
+#include <mraa/i2c.h>
 
 #define ADDR               0x4A // device address
 
@@ -122,14 +122,14 @@ class MAX44000 {
          * @param reg address of a register
          * @param value byte to be written
          */
-        maa_result_t i2cWriteReg (uint8_t reg, uint8_t value);
+        mraa_result_t i2cWriteReg (uint8_t reg, uint8_t value);
 
     private:
         std::string m_name;
 
         int m_maxControlAddr;
         int m_bus;
-        maa_i2c_context m_i2cMaxControlCtx;
+        mraa_i2c_context m_i2cMaxControlCtx;
 };
 
 }

src/mic/CMakeLists.txt

@@ -0,0 +1,5 @@
+set (libname "mic")
+set (libdescription "Microphone simple API")
+set (module_src ${libname}.cxx)
+set (module_h ${libname}.h)
+upm_module_init()

src/mic/jsupm_mic.i

@@ -0,0 +1,7 @@
+%module jsupm_mic
+
+%{
+    #include "mic.h"
+%}
+
+%include "mic.h"

src/mic/mic.cxx

@@ -0,0 +1,96 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <iostream>
+#include <unistd.h>
+#include <stdlib.h>
+#include <functional>
+#include <string.h>
+#include "mic.h"
+
+using namespace upm;
+
+Microphone::Microphone(int micPin) {
+    // initialise analog mic input
+    m_micCtx = mraa_aio_init(micPin);
+
+
+}
+
+Microphone::~Microphone() {
+    // close analog input
+    mraa_result_t error;
+    error = mraa_aio_close(m_micCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+}
+
+int
+Microphone::getSampledWindow (unsigned int freqMS, unsigned int numberOfSamples,
+                            uint16_t * buffer) {
+    int sampleIdx = 0;
+
+    // must have freq
+    if (!freqMS) {
+        return 0;
+    }
+
+    // too much samples
+    if (numberOfSamples > 0xFFFFFF) {
+        return 0;
+    }
+
+    while (sampleIdx < numberOfSamples) {
+        buffer[sampleIdx++] = mraa_aio_read (m_micCtx);
+        usleep(freqMS * 1000);
+    }
+
+    return sampleIdx;
+}
+
+int
+Microphone::findThreshold (thresholdContext* ctx, unsigned int threshold,
+                                uint16_t * buffer, unsigned int len) {
+    long sum = 0;
+    for (unsigned int i = 0; i < len; i++) {
+        sum += buffer[i];
+    }
+
+    ctx->averageReading = sum / len;
+    ctx->runningAverage = (((ctx->averagedOver-1) * ctx->runningAverage) + ctx->averageReading) / ctx->averagedOver;
+
+    if (ctx->runningAverage > threshold) {
+        return ctx->runningAverage;
+    } else {
+        return 0;
+    }
+}
+
+void
+Microphone::printGraph (thresholdContext* ctx) {
+    for (int i = 0; i < ctx->runningAverage; i++)
+        std::cout << ".";
+    std::cout << std::endl;
+}

src/mic/mic.h

@@ -0,0 +1,86 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <mraa/gpio.h>
+#include <mraa/aio.h>
+
+struct thresholdContext {
+    long averageReading;
+    long runningAverage;
+    int averagedOver;
+};
+
+namespace upm {
+
+/**
+ * @brief C++ API for Microphone
+ *
+ * This file defines the Microphone Analog sensor
+ *
+ * @snippet mic-example.cxx Interesting
+ *
+ */
+class Microphone {
+    public:
+        /**
+         * Instanciates a Microphone object
+         *
+         * @param micPin pin where microphone is connected
+         */
+        Microphone(int micPin);
+
+        /**
+         * MAX31723 object destructor
+         */
+        ~Microphone();
+
+        /**
+         * Get samples from microphone according to provided window and
+         * number of samples
+         *
+         * @return freqMS time between each sample (in microseconds)
+         * @return numberOfSamples number of sample to sample for this window
+         * @return buffer bufer with sampled data
+         */
+        int getSampledWindow (unsigned int freqMS, unsigned int numberOfSamples, uint16_t * buffer);
+
+        /**
+         * Given sampled buffer this method will return TRUE/FALSE if threshold
+         * was reached
+         *
+         * @return threshold sample threshold
+         * @return buffer buffer with samples
+         * @return len bufer len
+         */
+        int findThreshold (thresholdContext* ctx, unsigned int threshold, uint16_t * buffer, unsigned int len);
+
+        void printGraph (thresholdContext* ctx);
+
+    private:
+        mraa_aio_context    m_micCtx;
+};
+
+}

src/mic/pyupm_mic.i

@@ -0,0 +1,10 @@
+%module pyupm_mic
+
+%include "stdint.i"
+
+%feature("autodoc", "3");
+
+%include "mic.h"
+%{
+    #include "mic.h"
+%}

src/mma7455/mma7455.cxx

@@ -42,10 +42,10 @@ MMA7455::MMA7455 (int bus, int devAddr) {
     m_controlAddr = devAddr;
     m_bus = bus;
 
-    m_i2ControlCtx = maa_i2c_init(m_bus);
+    m_i2ControlCtx = mraa_i2c_init(m_bus);
 
-    maa_result_t error = maa_i2c_address(m_i2ControlCtx, m_controlAddr);
-    if (error != MAA_SUCCESS) {
+    mraa_result_t error = mraa_i2c_address(m_i2ControlCtx, m_controlAddr);
+    if (error != MRAA_SUCCESS) {
         fprintf(stderr, "Messed up i2c bus\n");
         return;
     }
@@ -53,24 +53,24 @@ MMA7455::MMA7455 (int bus, int devAddr) {
     // setting GLVL 0x1 (64LSB/g) and MODE 0x1 (Measurement Mode)
     data = (BIT (MMA7455_GLVL0) | BIT (MMA7455_MODE0));
     error = ic2WriteReg (MMA7455_MCTL, &data, 0x1);
-    if (error != MAA_SUCCESS) {
+    if (error != MRAA_SUCCESS) {
         std::cout << "ERROR :: MMA7455 instance wan not created (Mode)" << std::endl;
         return;
     }
     
-    if (MAA_SUCCESS != calibrate ()) {
+    if (MRAA_SUCCESS != calibrate ()) {
         std::cout << "ERROR :: MMA7455 instance wan not created (Calibrate)" << std::endl;
         return;
     }
 }
 
 MMA7455::~MMA7455() {
-    maa_i2c_stop(m_i2ControlCtx);
+    mraa_i2c_stop(m_i2ControlCtx);
 }
 
-maa_result_t 
+mraa_result_t 
 MMA7455::calibrate () {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     int i = 0;
     
     accelData xyz;
@@ -78,7 +78,7 @@ MMA7455::calibrate () {
     
     do {
         error = readData (&xyz.value.x, &xyz.value.y, &xyz.value.z);
-        if (MAA_SUCCESS != error) {
+        if (MRAA_SUCCESS != error) {
             return error;
         }
         
@@ -87,7 +87,7 @@ MMA7455::calibrate () {
         xyz.value.z += 2 * -(xyz.value.z - 64);
         
         error = ic2WriteReg (MMA7455_XOFFL,  (unsigned char *) &xyz, 0x6);
-        if (error != MAA_SUCCESS) {
+        if (error != MRAA_SUCCESS) {
             return error;
         }
     
@@ -96,7 +96,7 @@ MMA7455::calibrate () {
     return error;
 }
 
-maa_result_t 
+mraa_result_t 
 MMA7455::readData (short * ptrX, short * ptrY, short * ptrZ) {
     accelData xyz;
     unsigned char data = 0;
@@ -104,17 +104,17 @@ MMA7455::readData (short * ptrX, short * ptrY, short * ptrZ) {
     
     /*do {
         nBytes = ic2ReadReg (MMA7455_STATUS, &data, 0x1);
-    } while ( !(data & MMA7455_DRDY) && nBytes == MAA_SUCCESS);
+    } while ( !(data & MMA7455_DRDY) && nBytes == MRAA_SUCCESS);
     
-    if (nBytes == MAA_SUCCESS) {
+    if (nBytes == MRAA_SUCCESS) {
         std::cout << "NO_GDB :: 1" << std::endl;
-        return MAA_SUCCESS;
+        return MRAA_SUCCESS;
     }*/
     
     nBytes = ic2ReadReg (MMA7455_XOUTL, (unsigned char *) &xyz, 0x6);
     if (nBytes == 0) {
         std::cout << "NO_GDB :: 2" << std::endl;
-        return MAA_ERROR_UNSPECIFIED;
+        return MRAA_ERROR_UNSPECIFIED;
     }
     
     if (xyz.reg.x_msb & 0x02) {
@@ -134,40 +134,40 @@ MMA7455::readData (short * ptrX, short * ptrY, short * ptrZ) {
     *ptrY = xyz.value.y;
     *ptrZ = xyz.value.z;
     
-    return MAA_SUCCESS;
+    return MRAA_SUCCESS;
 }
 
 int 
 MMA7455::ic2ReadReg (unsigned char reg, unsigned char * buf, unsigned char size) {
-    if (MAA_SUCCESS != maa_i2c_address(m_i2ControlCtx, m_controlAddr)) {
+    if (MRAA_SUCCESS != mraa_i2c_address(m_i2ControlCtx, m_controlAddr)) {
         return 0;
     }
     
-    if (MAA_SUCCESS != maa_i2c_write_byte(m_i2ControlCtx, reg)) {
+    if (MRAA_SUCCESS != mraa_i2c_write_byte(m_i2ControlCtx, reg)) {
         return 0;
     }
 
-    if (MAA_SUCCESS != maa_i2c_address(m_i2ControlCtx, m_controlAddr)) {
+    if (MRAA_SUCCESS != mraa_i2c_address(m_i2ControlCtx, m_controlAddr)) {
         return 0;
     }
     
-    return (int) maa_i2c_read(m_i2ControlCtx, buf, size);
+    return (int) mraa_i2c_read(m_i2ControlCtx, buf, size);
 }
 
-maa_result_t 
+mraa_result_t 
 MMA7455::ic2WriteReg (unsigned char reg, unsigned char * buf, unsigned char size) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     uint8_t data[size + 1];
     data[0] = reg;
     memcpy(&data[1], buf, size);
 
-    error = maa_i2c_address (m_i2ControlCtx, m_controlAddr);
-    if (error != MAA_SUCCESS) {
+    error = mraa_i2c_address (m_i2ControlCtx, m_controlAddr);
+    if (error != MRAA_SUCCESS) {
         return error;
     }
-    error = maa_i2c_write (m_i2ControlCtx, data, size + 1);
-    if (error != MAA_SUCCESS) {
+    error = mraa_i2c_write (m_i2ControlCtx, data, size + 1);
+    if (error != MRAA_SUCCESS) {
         return error;
     }
 

src/mma7455/mma7455.h

@@ -24,7 +24,7 @@
 #pragma once
 
 #include <string>
-#include <maa/i2c.h>
+#include <mraa/i2c.h>
 
 #define ADDR               0x1D // device address
 
@@ -183,7 +183,7 @@ class MMA7455 {
         /**
          * Calibrate the sensor
          */
-        maa_result_t calibrate ();
+        mraa_result_t calibrate ();
         
         /**
          * Read X, Y and Z acceleration data
@@ -192,7 +192,7 @@ class MMA7455 {
          * @param ptrY Y axis
          * @param ptrZ Z axis
          */
-        maa_result_t readData (short * ptrX, short * ptrY, short * ptrZ);
+        mraa_result_t readData (short * ptrX, short * ptrY, short * ptrZ);
         
         /**
          * 
@@ -210,14 +210,14 @@ class MMA7455 {
          * @param buf register data buffer 
          * @param size buffer size
          */
-        maa_result_t ic2WriteReg (unsigned char reg, unsigned char * buf, unsigned char size);
+        mraa_result_t ic2WriteReg (unsigned char reg, unsigned char * buf, unsigned char size);
 
     private:
         std::string m_name;
 
         int              m_controlAddr;
         int              m_bus;
-        maa_i2c_context  m_i2ControlCtx;
+        mraa_i2c_context  m_i2ControlCtx;
 };
 
 }

src/mpu9150/CMakeLists.txt

@@ -0,0 +1,5 @@
+set (libname "mpu9150")
+set (libdescription "giro, acceleromter and magnometer sensor based on mpu9150")
+set (module_src ${libname}.cxx)
+set (module_h ${libname}.h)
+upm_module_init()

src/mpu9150/jsupm_mpu9150.i

@@ -0,0 +1,7 @@
+%module jsupm_mpu9150
+
+%{
+    #include "mpu9150.h"
+%}
+
+%include "mpu9150.h"

src/mpu9150/mpu9150.cxx

@@ -0,0 +1,226 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Based on InvenSense MPU-6050 register map document rev. 2.0, 5/19/2011 (RM-MPU-6000A-00)
+ * 8/24/2011 by Jeff Rowberg <jeff@rowberg.net>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <iostream>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "mpu9150.h"
+
+using namespace upm;
+
+MPU9150::MPU9150 (int bus, int devAddr) {
+    m_name = "MPU9150";
+
+    m_i2cAddr = devAddr;
+    m_bus = bus;
+
+    m_i2Ctx = mraa_i2c_init(m_bus);
+
+    mraa_result_t ret = mraa_i2c_address(m_i2Ctx, m_i2cAddr);
+    if (ret != MRAA_SUCCESS) {
+        fprintf(stderr, "Messed up i2c bus\n");
+    }
+
+    initSensor ();
+}
+
+MPU9150::~MPU9150() {
+    mraa_i2c_stop(m_i2Ctx);
+}
+
+mraa_result_t
+MPU9150::initSensor () {
+    uint8_t regData = 0x0;
+
+    // setClockSource
+    updateRegBits ( MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CLKSEL_BIT,
+                    MPU6050_PWR1_CLKSEL_LENGTH, MPU6050_CLOCK_PLL_XGYRO);
+    // setFullScaleGyroRange
+    updateRegBits ( MPU6050_RA_GYRO_CONFIG, MPU6050_GCONFIG_FS_SEL_BIT,
+                    MPU6050_GCONFIG_FS_SEL_LENGTH, MPU6050_GYRO_FS_250);
+    // setFullScaleAccelRange
+    updateRegBits ( MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_AFS_SEL_BIT,
+                    MPU6050_ACONFIG_AFS_SEL_LENGTH, MPU6050_ACCEL_FS_2);
+    // setSleepEnabled
+    i2cReadReg_N (MPU6050_RA_PWR_MGMT_1, 0x1, &regData);
+    regData &= ~(1 << MPU6050_PWR1_SLEEP_BIT);
+    i2cWriteReg (MPU6050_RA_PWR_MGMT_1, regData);
+
+    return MRAA_SUCCESS;
+}
+
+uint8_t
+MPU9150::getDeviceID () {
+    uint8_t regData = 0x0;
+    getRegBits (MPU6050_RA_WHO_AM_I, MPU6050_WHO_AM_I_BIT, MPU6050_WHO_AM_I_LENGTH, &regData);
+    return regData;
+}
+
+mraa_result_t
+MPU9150::getData () {
+    uint8_t buffer[14];
+
+    for (int i = 0; i < SMOOTH_TIMES; i++) {
+        i2cReadReg_N (MPU6050_RA_ACCEL_XOUT_H, 14, buffer);
+        axisAcceleromter.rawData.axisX  = (((int16_t)buffer[0]) << 8)  | buffer[1];
+        axisAcceleromter.rawData.axisY  = (((int16_t)buffer[2]) << 8)  | buffer[3];
+        axisAcceleromter.rawData.axisZ  = (((int16_t)buffer[4]) << 8)  | buffer[5];
+        axisAcceleromter.sumData.axisX  += (double) axisAcceleromter.rawData.axisX / 16384;
+        axisAcceleromter.sumData.axisY  += (double) axisAcceleromter.rawData.axisY / 16384;
+        axisAcceleromter.sumData.axisZ  += (double) axisAcceleromter.rawData.axisZ / 16384;
+
+        axisGyroscope.rawData.axisX     = (((int16_t)buffer[8]) << 8)  | buffer[9];
+        axisGyroscope.rawData.axisY     = (((int16_t)buffer[10]) << 8) | buffer[11];
+        axisGyroscope.rawData.axisZ     = (((int16_t)buffer[12]) << 8) | buffer[13];
+        axisGyroscope.sumData.axisX     += (double) axisAcceleromter.rawData.axisX * 250 / 32768;
+        axisGyroscope.sumData.axisY     += (double) axisAcceleromter.rawData.axisY * 250 / 32768;
+        axisGyroscope.sumData.axisZ     += (double) axisAcceleromter.rawData.axisZ * 250 / 32768;
+
+        i2cWriteReg (MPU6050_RA_INT_PIN_CFG, 0x02);
+        usleep (10000);
+        m_i2cAddr = MPU9150_RA_MAG_ADDRESS;
+        i2cWriteReg (0x0A, 0x01);
+        usleep (10000);
+        i2cReadReg_N (MPU9150_RA_MAG_XOUT_L, 6, buffer);
+        m_i2cAddr = ADDR;
+
+        axisMagnetomer.rawData.axisX  = (((int16_t)buffer[0]) << 8)  | buffer[1];
+        axisMagnetomer.rawData.axisY  = (((int16_t)buffer[2]) << 8)  | buffer[3];
+        axisMagnetomer.rawData.axisZ  = (((int16_t)buffer[4]) << 8)  | buffer[5];
+        axisMagnetomer.sumData.axisX  += (double) axisMagnetomer.rawData.axisX * 1200 / 4096;
+        axisMagnetomer.sumData.axisY  += (double) axisMagnetomer.rawData.axisY * 1200 / 4096;
+        axisMagnetomer.sumData.axisZ  += (double) axisMagnetomer.rawData.axisZ * 1200 / 4096;
+    }
+
+    axisAcceleromter.data.axisX = axisAcceleromter.sumData.axisX / SMOOTH_TIMES;
+    axisAcceleromter.data.axisY = axisAcceleromter.sumData.axisY / SMOOTH_TIMES;
+    axisAcceleromter.data.axisZ = axisAcceleromter.sumData.axisZ / SMOOTH_TIMES;
+
+    axisGyroscope.data.axisX = axisGyroscope.sumData.axisX / SMOOTH_TIMES;
+    axisGyroscope.data.axisY = axisGyroscope.sumData.axisY / SMOOTH_TIMES;
+    axisGyroscope.data.axisZ = axisGyroscope.sumData.axisZ / SMOOTH_TIMES;
+
+    axisMagnetomer.data.axisX = axisMagnetomer.sumData.axisX / SMOOTH_TIMES;
+    axisMagnetomer.data.axisY = axisMagnetomer.sumData.axisY / SMOOTH_TIMES;
+    axisMagnetomer.data.axisZ = axisMagnetomer.sumData.axisZ / SMOOTH_TIMES;
+}
+
+mraa_result_t
+MPU9150::getAcceleromter (Vector3D * data) {
+    data->axisX = axisAcceleromter.data.axisX;
+    data->axisY = axisAcceleromter.data.axisY;
+    data->axisZ = axisAcceleromter.data.axisZ;
+
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+MPU9150::getGyro (Vector3D * data) {
+    data->axisX = axisGyroscope.data.axisX;
+    data->axisY = axisGyroscope.data.axisY;
+    data->axisZ = axisGyroscope.data.axisZ;
+
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+MPU9150::getMagnometer (Vector3D * data) {
+    data->axisX = axisMagnetomer.data.axisX;
+    data->axisY = axisMagnetomer.data.axisY;
+    data->axisZ = axisMagnetomer.data.axisZ;
+
+    return MRAA_SUCCESS;
+}
+
+float
+MPU9150::getTemperature () {
+    uint8_t buffer[2];
+    uint16_t tempRaw = 0;
+
+    updateRegBits (MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_TEMP_DIS_BIT, 0x1, 0x0);
+    i2cReadReg_N (MPU6050_RA_TEMP_OUT_H, 2, buffer);
+    tempRaw = (((int16_t)buffer[0]) << 8) | buffer[1];
+
+    return (float)tempRaw / 340.0 + 35.0;
+}
+
+/*
+ * **************
+ *  private area
+ * **************
+ */
+uint16_t
+MPU9150::i2cReadReg_N (int reg, unsigned int len, uint8_t * buffer) {
+    int readByte = 0;
+    mraa_i2c_address(m_i2Ctx, m_i2cAddr);
+    mraa_i2c_write_byte(m_i2Ctx, reg);
+
+    mraa_i2c_address(m_i2Ctx, m_i2cAddr);
+    readByte = mraa_i2c_read(m_i2Ctx, buffer, len);
+    return readByte;
+}
+
+mraa_result_t
+MPU9150::i2cWriteReg (uint8_t reg, uint8_t value) {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    uint8_t data[2] = { reg, value };
+    error = mraa_i2c_address (m_i2Ctx, m_i2cAddr);
+    error = mraa_i2c_write (m_i2Ctx, data, 2);
+
+    return error;
+}
+
+int
+MPU9150::updateRegBits (uint8_t reg, uint8_t bitStart, uint8_t length, uint16_t data) {
+    uint8_t regData;
+
+    if (i2cReadReg_N (reg, 0x1, &regData) != 0) {
+        uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
+        data <<= (bitStart - length + 1); // shift data into correct position
+        data &= mask; // zero all non-important bits in data
+        regData &= ~(mask); // zero all important bits in existing byte
+        regData |= data; // combine data with existing byte
+        return i2cWriteReg (reg, regData);
+    } else {
+        return 0x0;
+    }
+}
+
+uint8_t
+MPU9150::getRegBits (uint8_t reg, uint8_t bitStart, uint8_t length, uint8_t * data) {
+    uint8_t count = 0;
+    uint8_t regData;
+    if (i2cReadReg_N (reg, 0x1, &regData) != 0) {
+        uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
+        regData &= mask;
+        regData >>= (bitStart - length + 1);
+        *data = regData;
+    }
+    return count;
+}

src/mpu9150/mpu9150.h

@@ -0,0 +1,196 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Based on InvenSense MPU-6050 register map document rev. 2.0, 5/19/2011 (RM-MPU-6000A-00)
+ * 8/24/2011 by Jeff Rowberg <jeff@rowberg.net>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <mraa/i2c.h>
+
+#define MPU6050_ADDRESS_AD0_LOW             0x68 // address pin low (GND), default for InvenSense evaluation board
+#define MPU6050_ADDRESS_AD0_HIGH            0x69 // address pin high (VCC)
+#define ADDR                                MPU6050_ADDRESS_AD0_LOW // device address
+
+// registers address
+#define MPU6050_CLOCK_PLL_XGYRO             0x01
+#define MPU6050_GYRO_FS_250                 0x00
+#define MPU6050_ACCEL_FS_2                  0x00
+#define MPU6050_RA_INT_PIN_CFG              0x37
+
+#define MPU6050_RA_ACCEL_XOUT_H             0x3B
+#define MPU6050_RA_ACCEL_XOUT_L             0x3C
+#define MPU6050_RA_ACCEL_YOUT_H             0x3D
+#define MPU6050_RA_ACCEL_YOUT_L             0x3E
+#define MPU6050_RA_ACCEL_ZOUT_H             0x3F
+#define MPU6050_RA_ACCEL_ZOUT_L             0x40
+#define MPU6050_RA_TEMP_OUT_H               0x41
+#define MPU6050_RA_TEMP_OUT_L               0x42
+#define MPU6050_RA_GYRO_XOUT_H              0x43
+#define MPU6050_RA_GYRO_XOUT_L              0x44
+#define MPU6050_RA_GYRO_YOUT_H              0x45
+#define MPU6050_RA_GYRO_YOUT_L              0x46
+#define MPU6050_RA_GYRO_ZOUT_H              0x47
+#define MPU6050_RA_GYRO_ZOUT_L              0x48
+
+#define MPU6050_RA_CONFIG                   0x1A
+#define MPU6050_CFG_DLPF_CFG_BIT            2
+#define MPU6050_CFG_DLPF_CFG_LENGTH         3
+
+#define MPU6050_RA_GYRO_CONFIG              0x1B
+#define MPU6050_GCONFIG_FS_SEL_BIT          4
+#define MPU6050_GCONFIG_FS_SEL_LENGTH       2
+
+#define MPU6050_RA_ACCEL_CONFIG             0x1C
+#define MPU6050_ACONFIG_AFS_SEL_BIT         4
+#define MPU6050_ACONFIG_AFS_SEL_LENGTH      2
+
+// magnotometer
+#define MPU9150_RA_MAG_ADDRESS              0x0C
+#define MPU9150_RA_MAG_XOUT_L               0x03
+
+#define MPU6050_RA_PWR_MGMT_1               0x6B
+#define MPU6050_PWR1_CLKSEL_BIT             2
+#define MPU6050_PWR1_CLKSEL_LENGTH          3
+#define MPU6050_PWR1_SLEEP_BIT              6
+
+#define MPU6050_RA_INT_PIN_CFG              0x37
+
+// temperature
+#define MPU6050_PWR1_TEMP_DIS_BIT           3
+#define MPU6050_RA_WHO_AM_I                 0x75
+#define MPU6050_WHO_AM_I_BIT                6
+#define MPU6050_WHO_AM_I_LENGTH             6
+
+#define SMOOTH_TIMES                        10.0
+
+#define HIGH               1
+#define LOW                0
+
+namespace upm {
+
+struct Vector3DRaw {
+    uint16_t axisX;
+    uint16_t axisY;
+    uint16_t axisZ;
+};
+
+struct Vector3D {
+    double axisX;
+    double axisY;
+    double axisZ;
+};
+
+struct AxisData {
+    Vector3DRaw rawData;
+    Vector3D    sumData;
+    Vector3D    data;
+};
+
+/**
+ * @brief C++ API for MPU9150 chip (Accelrometer, Gyro and Magnometer Sensor)
+ *
+ * This file defines the MPU9150 C++ interface for libmpu9150
+ *
+ * @snippet mpu9150-example.cxx Interesting
+ */
+class MPU9150 {
+    public:
+        /**
+         * Instanciates a MPU9150 object
+         *
+         * @param bus number of used bus
+         * @param devAddr addres of used i2c device
+         */
+        MPU9150 (int bus, int devAddr);
+
+        /**
+         * MPU9150 object destructor, basicaly it close i2c connection.
+         */
+        ~MPU9150 ();
+
+        /**
+         * Initiate MPU9150 chips
+         */
+        mraa_result_t initSensor ();
+
+        /**
+         * Get identity of the device
+         */
+        uint8_t getDeviceID ();
+
+        /**
+         * Get the Accelerometer, Gyro and Compass data from the chip and
+         * save it in private section.
+         */
+        mraa_result_t getData ();
+
+        /**
+         * @param data structure with 3 axis (x,y,z)
+         */
+        mraa_result_t getAcceleromter (Vector3D * data);
+
+        /**
+         * @param data structure with 3 axis (x,y,z)
+         */
+        mraa_result_t getGyro (Vector3D * data);
+
+        /**
+         * @param data structure with 3 axis (x,y,z)
+         */
+        mraa_result_t getMagnometer (Vector3D * data);
+
+        /**
+         * Read on die temperature from the chip
+         */
+        float getTemperature ();
+
+        /**
+         * Return name of the component
+         */
+        std::string name()
+        {
+            return m_name;
+        }
+
+    private:
+        std::string m_name;
+
+        int m_i2cAddr;
+        int m_bus;
+        mraa_i2c_context m_i2Ctx;
+
+        AxisData axisMagnetomer;
+        AxisData axisAcceleromter;
+        AxisData axisGyroscope;
+
+        uint16_t i2cReadReg_N (int reg, unsigned int len, uint8_t * buffer);
+        mraa_result_t i2cWriteReg (uint8_t reg, uint8_t value);
+        int updateRegBits (uint8_t reg, uint8_t bitStart,
+                                    uint8_t length, uint16_t data);
+        uint8_t getRegBits (uint8_t reg, uint8_t bitStart,
+                                    uint8_t length, uint8_t * data);
+};
+
+}

src/mpu9150/pyupm_mpu9150.i

@@ -0,0 +1,10 @@
+%module pyupm_mpu9150
+
+%include "stdint.i"
+
+%feature("autodoc", "3");
+
+%include "mpu9150.h"
+%{
+    #include "mpu9150.h"
+%}

src/my9221/my9221.cxx

@@ -31,51 +31,51 @@
 using namespace upm;
 
 MY9221::MY9221 (uint8_t di, uint8_t dcki) {
-    maa_result_t error = MAA_SUCCESS;
-    maa_init();
+    mraa_result_t error = MRAA_SUCCESS;
+    mraa_init();
 
     // init clock context
-    m_clkPinCtx = maa_gpio_init(dcki);
+    m_clkPinCtx = mraa_gpio_init(dcki);
     if (m_clkPinCtx == NULL) {
         fprintf(stderr, "Are you sure that pin%d you requested is valid on your platform?", dcki);
         exit(1);
     }
     // init data context
-    m_dataPinCtx = maa_gpio_init(di);
+    m_dataPinCtx = mraa_gpio_init(di);
     if (m_dataPinCtx == NULL) {
         fprintf(stderr, "Are you sure that pin%d you requested is valid on your platform?", di);
         exit(1);
     }
     
     // set direction (out)
-    error = maa_gpio_dir(m_clkPinCtx, MAA_GPIO_OUT);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_dir(m_clkPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 
     // set direction (out)
-    error = maa_gpio_dir(m_dataPinCtx, MAA_GPIO_OUT);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_dir(m_dataPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 }
 
 MY9221::~MY9221() {
-    maa_result_t error = MAA_SUCCESS;
-    error = maa_gpio_close (m_dataPinCtx);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    mraa_result_t error = MRAA_SUCCESS;
+    error = mraa_gpio_close (m_dataPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
-    error = maa_gpio_close (m_clkPinCtx);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_close (m_clkPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 }
 
-maa_result_t
+mraa_result_t
 MY9221::setBarLevel (uint8_t level) {
     if (level > 10) {
-        return MAA_ERROR_INVALID_PARAMETER;
+        return MRAA_ERROR_INVALID_PARAMETER;
     }
 
     send16bitBlock (CMDMODE);
@@ -86,25 +86,25 @@ MY9221::setBarLevel (uint8_t level) {
     lockData ();
 }
 
-maa_result_t
+mraa_result_t
 MY9221::lockData () {
-    maa_result_t error = MAA_SUCCESS;
-    error = maa_gpio_write (m_dataPinCtx, LOW);
+    mraa_result_t error = MRAA_SUCCESS;
+    error = mraa_gpio_write (m_dataPinCtx, LOW);
     usleep(100);
     
     for(int idx = 0; idx < 4; idx++) {
-        error = maa_gpio_write (m_dataPinCtx, HIGH);
-        error = maa_gpio_write (m_dataPinCtx, LOW);
+        error = mraa_gpio_write (m_dataPinCtx, HIGH);
+        error = mraa_gpio_write (m_dataPinCtx, LOW);
     }
 }
 
-maa_result_t
+mraa_result_t
 MY9221::send16bitBlock (short data) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
     for (uint8_t bit_idx = 0; bit_idx < MAX_BIT_PER_BLOCK; bit_idx++) {
         uint32_t state = (data & 0x8000) ? HIGH : LOW;
-        error = maa_gpio_write (m_dataPinCtx, state);
-        state = maa_gpio_read (m_clkPinCtx);
+        error = mraa_gpio_write (m_dataPinCtx, state);
+        state = mraa_gpio_read (m_clkPinCtx);
 
         if (state) {
             state = LOW;
@@ -112,7 +112,7 @@ MY9221::send16bitBlock (short data) {
             state = HIGH;
         }
 
-        error = maa_gpio_write (m_clkPinCtx, state);
+        error = mraa_gpio_write (m_clkPinCtx, state);
 
         data <<= 1;
     }

src/my9221/my9221.h

@@ -24,8 +24,8 @@
 #pragma once
 
 #include <string>
-#include <maa/aio.h>
-#include <maa/gpio.h>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
 
 #define MAX_BIT_PER_BLOCK     16
 #define CMDMODE               0x0000
@@ -64,7 +64,7 @@ class MY9221 {
          *
          * @param level selected level for the bar (1 - 10)
          */
-        maa_result_t setBarLevel (uint8_t level);
+        mraa_result_t setBarLevel (uint8_t level);
 
         /**
          * Return name of the component
@@ -74,12 +74,12 @@ class MY9221 {
             return m_name;
         }
     private:
-        maa_result_t lockData ();
-        maa_result_t send16bitBlock (short data);
+        mraa_result_t lockData ();
+        mraa_result_t send16bitBlock (short data);
 
         std::string m_name;
-        maa_gpio_context m_clkPinCtx;
-        maa_gpio_context m_dataPinCtx;
+        mraa_gpio_context m_clkPinCtx;
+        mraa_gpio_context m_dataPinCtx;
 };
 
 }

src/nrf24l01/nrf24l01.cxx

@@ -31,58 +31,58 @@
 using namespace upm;
 
 NRF24l01::NRF24l01 (uint8_t cs) {
-    maa_init();
+    mraa_init();
     nrfInitModule (cs, 8);
 }
 
 NRF24l01::~NRF24l01 () {
-    maa_result_t error = MAA_SUCCESS;
-    error = maa_spi_stop(m_spi);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    mraa_result_t error = MRAA_SUCCESS;
+    error = mraa_spi_stop(m_spi);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
-    error = maa_gpio_close (m_cePinCtx);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_close (m_cePinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
-    error = maa_gpio_close (m_csnPinCtx);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_close (m_csnPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 }
 
 void
 NRF24l01::nrfInitModule (uint8_t chip_select, uint8_t chip_enable) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
 
     m_csn         = chip_select;
     m_ce         = chip_enable;
     m_channel     = 1;
 
-    m_csnPinCtx = maa_gpio_init (m_csn);
+    m_csnPinCtx = mraa_gpio_init (m_csn);
     if (m_csnPinCtx == NULL) {
         fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_csn);
         exit (1);
     }
 
-    m_cePinCtx = maa_gpio_init (m_ce);
+    m_cePinCtx = mraa_gpio_init (m_ce);
     if (m_cePinCtx == NULL) {
         fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_ce);
         exit (1);
     }
 
-    error = maa_gpio_dir (m_csnPinCtx, MAA_GPIO_OUT);
-    if (error != MAA_SUCCESS) {
-        maa_result_print (error);
+    error = mraa_gpio_dir (m_csnPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
     }
 
-    error = maa_gpio_dir (m_cePinCtx, MAA_GPIO_OUT);
-    if (error != MAA_SUCCESS) {
-        maa_result_print (error);
+    error = mraa_gpio_dir (m_cePinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
     }
 
     nrfCELow ();
-    m_spi = maa_spi_init (0);
+    m_spi = mraa_spi_init (0);
 }
 
 void
@@ -105,8 +105,8 @@ NRF24l01::nrfConfigModule() {
 void
 NRF24l01::nrfConfigRegister(uint8_t reg, uint8_t value) {
     nrfCSOn ();
-    maa_spi_write (m_spi, W_REGISTER | (REGISTER_MASK & reg));
-    maa_spi_write (m_spi, value);
+    mraa_spi_write (m_spi, W_REGISTER | (REGISTER_MASK & reg));
+    mraa_spi_write (m_spi, value);
     nrfCSOff ();
 }
 
@@ -122,7 +122,7 @@ NRF24l01::nrfPowerUpRX() {
 void
 NRF24l01::nrfFlushRX() {
     nrfCSOn ();
-    maa_spi_write (m_spi, FLUSH_RX);
+    mraa_spi_write (m_spi, FLUSH_RX);
     nrfCSOff ();
 }
 
@@ -160,7 +160,7 @@ void
 NRF24l01::nrfWriteRegister(uint8_t reg, uint8_t * value, uint8_t len)
 {
     nrfCSOn ();
-    maa_spi_write (m_spi, W_REGISTER | (REGISTER_MASK & reg));
+    mraa_spi_write (m_spi, W_REGISTER | (REGISTER_MASK & reg));
     nrfTransmitSync(value, len);
     nrfCSOff ();
 }
@@ -169,7 +169,7 @@ void
 NRF24l01::nrfTransmitSync(uint8_t *dataout, uint8_t len){
     uint8_t i;
     for(i = 0; i < len; i++) {
-        maa_spi_write (m_spi, dataout[i]);
+        mraa_spi_write (m_spi, dataout[i]);
     }
 }
 
@@ -196,7 +196,7 @@ void
 NRF24l01::nrfReadRegister (uint8_t reg, uint8_t * value, uint8_t len)
 {
     nrfCSOn ();
-    maa_spi_write (m_spi, R_REGISTER | (REGISTER_MASK & reg));
+    mraa_spi_write (m_spi, R_REGISTER | (REGISTER_MASK & reg));
     nrfTransferSync (value, value, len);
     nrfCSOff ();
 }
@@ -205,7 +205,7 @@ void
 NRF24l01::nrfTransferSync (uint8_t *dataout,uint8_t *datain,uint8_t len) {
     uint8_t i;
     for(i = 0;i < len;i++) {
-        datain[i] = maa_spi_write (m_spi, dataout[i]);
+        datain[i] = mraa_spi_write (m_spi, dataout[i]);
     }
 }
 
@@ -222,7 +222,7 @@ NRF24l01::nrfGetData (uint8_t * data)
 {
     nrfCSOn ();
     /* Send cmd to read rx payload */
-    maa_spi_write (m_spi, R_RX_PAYLOAD);
+    mraa_spi_write (m_spi, R_RX_PAYLOAD);
     /* Read payload */
     nrfTransferSync(data, data, m_payload);
     nrfCSOff ();
@@ -248,11 +248,11 @@ NRF24l01::nrfSend(uint8_t * value) {
     nrfCELow();
     nrfPowerUpTX();                            // Set to transmitter mode , Power up
     nrfCSOn ();
-    maa_spi_write (m_spi, FLUSH_TX);        // Write cmd to flush tx fifo
+    mraa_spi_write (m_spi, FLUSH_TX);        // Write cmd to flush tx fifo
     nrfCSOff ();
 
     nrfCSOn ();
-    maa_spi_write (m_spi, W_TX_PAYLOAD);     // Write cmd to write payload
+    mraa_spi_write (m_spi, W_TX_PAYLOAD);     // Write cmd to write payload
     nrfTransmitSync(value, m_payload);        // Write payload
     nrfCSOff ();
     nrfCEHigh();                            // Start transmission
@@ -290,24 +290,24 @@ NRF24l01::nrfPowerDown () {
     nrfConfigRegister (CONFIG, NRF_CONFIG);
 }
 
-maa_result_t
+mraa_result_t
 NRF24l01::nrfCEHigh () {
-    return maa_gpio_write (m_cePinCtx, HIGH);
+    return mraa_gpio_write (m_cePinCtx, HIGH);
 }
 
-maa_result_t
+mraa_result_t
 NRF24l01::nrfCELow () {
-    return maa_gpio_write (m_cePinCtx, LOW);
+    return mraa_gpio_write (m_cePinCtx, LOW);
 }
 
-maa_result_t
+mraa_result_t
 NRF24l01::nrfCSOn () {
-    return maa_gpio_write (m_csnPinCtx, LOW);
+    return mraa_gpio_write (m_csnPinCtx, LOW);
 }
 
-maa_result_t
+mraa_result_t
 NRF24l01::nrfCSOff () {
-    return maa_gpio_write (m_csnPinCtx, HIGH);
+    return mraa_gpio_write (m_csnPinCtx, HIGH);
 }
 
 void

src/nrf24l01/nrf24l01.h

@@ -24,9 +24,9 @@
 #pragma once
 
 #include <string>
-#include <maa/aio.h>
-#include <maa/gpio.h>
-#include <maa/spi.h>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
+#include <mraa/spi.h>
 
 /* Memory Map */
 #define CONFIG              0x00
@@ -297,22 +297,22 @@ class NRF24l01 {
         /**
          * Set chip enable pin HIGH
          */
-        maa_result_t nrfCEHigh ();
+        mraa_result_t nrfCEHigh ();
 
         /**
          * Set chip enable LOW
          */
-        maa_result_t nrfCELow ();
+        mraa_result_t nrfCELow ();
 
         /**
          * Set chip select pin LOW
          */
-        maa_result_t nrfCSOn ();
+        mraa_result_t nrfCSOn ();
 
         /**
          * Set chip select pin HIGH
          */
-        maa_result_t nrfCSOff ();
+        mraa_result_t nrfCSOff ();
 
         /**
          * Flush reciver stack
@@ -330,7 +330,7 @@ class NRF24l01 {
 
         funcPtrVoidVoid dataRecievedHandler; /**< Data arrived handler */
     private:
-        maa_spi_context        m_spi;
+        mraa_spi_context        m_spi;
         uint8_t                m_ce;
         uint8_t                m_csn;
         uint8_t                m_channel;
@@ -338,8 +338,8 @@ class NRF24l01 {
         uint8_t                m_payload;
         uint8_t                m_localAddress[5];
 
-        maa_gpio_context     m_csnPinCtx;
-        maa_gpio_context     m_cePinCtx;
+        mraa_gpio_context     m_csnPinCtx;
+        mraa_gpio_context     m_cePinCtx;
 
         std::string         m_name;
 };

src/pulsensor/CMakeLists.txt

@@ -0,0 +1,5 @@
+set (libname "pulsensor")
+set (libdescription "upm PULSENSOR")
+set (module_src ${libname}.cxx)
+set (module_h ${libname}.h)
+upm_module_init()

src/pulsensor/jsupm_pulsensor.i

@@ -0,0 +1,7 @@
+%module jsupm_pulsensor
+
+%{
+    #include "pulsensor.h"
+%}
+
+%include "pulsensor.h"

src/pulsensor/pulsensor.cxx

@@ -0,0 +1,147 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <unistd.h>
+#include <stdlib.h>
+#include "pulsensor.h"
+
+void init_pulsensor (pulsensor_context * ctx, callback_handler handler) {
+    ctx->callback = handler;
+    
+    ctx->pin_ctx = mraa_aio_init(0);
+    
+    ctx->sample_counter = 0;
+    ctx->last_beat_time = 0;
+    ctx->threshold      = 512;
+    ctx->ibi            = 600;
+    ctx->trough         = 512;
+    ctx->peak           = 512;
+    ctx->is_pulse       = FALSE;
+    ctx->ret            = FALSE;
+    ctx->bpm            = 0;
+    ctx->qs             = FALSE;
+    ctx->apmlitude      = 100;
+}
+
+void start_sampler (pulsensor_context * ctx) {
+    int error;
+    ctx_counter++;
+    usleep (100000);
+    error = pthread_create (&(ctx->sample_thread), NULL, do_sample, (void *) ctx);
+    if (error != 0) {
+        printf ("ERROR : Cannot created sampler thread.\n");
+    }
+}
+
+void stop_sampler (pulsensor_context * ctx) {
+    ctx_counter--;
+}
+
+void * do_sample (void * arg) {
+    int data_from_sensor;
+    clbk_data callback_data;
+    while (ctx_counter) {
+        pulsensor_context * ctx = (pulsensor_context *) arg;
+        mraa_aio_context pin = ctx->pin_ctx;
+        data_from_sensor = mraa_aio_read (pin);
+        ctx->ret = FALSE;
+        
+        ctx->sample_counter += 2;
+        int N = ctx->sample_counter - ctx->last_beat_time;
+        
+        if (data_from_sensor < ctx->threshold && N > ( ctx->ibi / 5)* 3) {
+            if (data_from_sensor < ctx->trough) {
+                ctx->trough = data_from_sensor;
+            }
+        }
+        
+        if (data_from_sensor > ctx->threshold && data_from_sensor > ctx->peak) {
+            ctx->peak = data_from_sensor;
+        }
+        
+        if (N > 250) {
+            // printf ("(NO_GDB) DEBUG\n");
+            if ( (data_from_sensor > ctx->threshold) && 
+                    (ctx->is_pulse == FALSE) && 
+                    (N > (ctx->ibi / 5)* 3) ) {
+                ctx->is_pulse = callback_data.is_heart_beat = TRUE;
+                ((pulsensor_context *) arg)->callback(callback_data);
+                
+                ctx->ibi = ctx->sample_counter - ctx->last_beat_time;
+                ctx->last_beat_time = ctx->sample_counter;
+                
+                // second beat
+                if (ctx->second_beat) {
+                    ctx->second_beat = FALSE;
+                    for (int i = 0; i <= 9; i++) {
+                        ctx->ibi_rate[i] = ctx->ibi;                      
+                    }
+                }
+                
+                // first beat
+                if (ctx->first_beat) {
+                    ctx->first_beat  = FALSE;
+                    ctx->second_beat = TRUE;
+                    ctx->ret = TRUE;
+                } else {                    
+                    uint32_t running_total = 0;
+                    for(int i = 0; i <= 8; i++){
+                        ctx->ibi_rate[i] = ctx->ibi_rate[i+1];
+                        running_total += ctx->ibi_rate[i];
+                    }
+                    
+                    ctx->ibi_rate[9] = ctx->ibi;
+                    running_total += ctx->ibi_rate[9];
+                    running_total /= 10;
+                    ctx->bpm = 60000 / running_total;
+                    ctx->qs = TRUE;
+                }
+            }
+        }
+        
+        if (ctx->ret == FALSE) {
+            if (data_from_sensor < ctx->threshold && ctx->is_pulse == TRUE) {
+                ctx->is_pulse = callback_data.is_heart_beat = FALSE;
+                ((pulsensor_context *) arg)->callback(callback_data);
+                
+                ctx->is_pulse   = FALSE;
+                ctx->apmlitude  = ctx->peak - ctx->trough;
+                ctx->threshold  = ctx->apmlitude / 2 + ctx->trough;
+                ctx->peak       = ctx->threshold;
+                ctx->trough     = ctx->threshold;
+            }
+
+            if (N > 2500) {
+                ctx->threshold      = 512;
+                ctx->peak           = 512;
+                ctx->trough         = 512;
+                ctx->last_beat_time = ctx->sample_counter;    
+                ctx->first_beat     = TRUE;
+                ctx->second_beat    = FALSE;
+            }
+        }
+        
+        usleep (2000);
+    }
+}

src/pulsensor/pulsensor.h

@@ -0,0 +1,76 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Credits to Adafruit.
+ * Based on Adafruit BMP085 library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <math.h>
+#include <mraa/pwm.h>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
+#include <pthread.h>
+
+#define HIGH               1
+#define LOW                0
+
+#define TRUE               HIGH
+#define FALSE              LOW
+
+struct clbk_data {
+    int is_heart_beat;
+};
+
+typedef void (* callback_handler) (clbk_data);
+
+struct pulsensor_context {
+    pthread_t        sample_thread;
+    uint32_t         sample_counter;
+    uint32_t         last_beat_time;
+    int              threshold;
+    int              ibi_rate[10];
+    int              ibi;
+    int              trough;
+    int              peak;
+    int              bpm;
+    int              apmlitude;
+    uint8_t          qs;
+    uint8_t          is_pulse;
+    uint8_t          first_beat;
+    uint8_t          second_beat;
+    uint8_t          pin;
+    uint8_t          ret;
+    mraa_aio_context  pin_ctx;
+    
+    callback_handler callback;
+};
+
+static volatile uint16_t ctx_counter = 0;
+
+void init_pulsensor (pulsensor_context * ctx, callback_handler handler);
+void start_sampler (pulsensor_context * ctx);
+void stop_sampler (pulsensor_context * ctx);
+
+void * do_sample (void * arg);

src/pulsensor/pyupm_pulsensor.i

@@ -0,0 +1,10 @@
+%module pyupm_pulsensor
+
+%include "stdint.i"
+
+%feature("autodoc", "3");
+
+%include "pulsensor.h"
+%{
+    #include "pulsensor.h"
+%}

src/servo/es08a.cxx

@@ -30,8 +30,10 @@
 using namespace upm;
 
 ES08A::ES08A (int pin) : Servo(pin) {
-    m_name     = "ES08A";
-    m_maxAngle = 180.0;
+    m_name          = "ES08A";
+    m_maxAngle      = 180.0;
+    m_minPulseWidth = 600;
+    m_maxPulseWidth = 2200;
 }
 
 ES08A::~ES08A() {

src/servo/es08a.h

@@ -28,9 +28,6 @@
 
 namespace upm {
 
-#define MIN_PULSE_WIDTH      600
-#define MAX_PULSE_WIDTH      2500
-
 /**
  * @brief C++ API for ES08A servo component
  *

src/servo/servo.cxx

@@ -25,21 +25,30 @@
 #include <iostream>
 #include <unistd.h>
 #include <stdlib.h>
+#include <math.h>
 
 #include "servo.h"
 
 using namespace upm;
 
 Servo::Servo (int pin) {
-    maa_result_t error = MAA_SUCCESS;
+    mraa_result_t error = MRAA_SUCCESS;
+
+    m_minPulseWidth   = MIN_PULSE_WIDTH;
+    m_maxPulseWidth   = MAX_PULSE_WIDTH;
+    m_maxPeriod       = MAX_PERIOD;
 
     m_maxAngle        = 180.0;
     m_servoPin        = pin;
-    m_pwmServoContext = maa_pwm_init (m_servoPin);
+    m_pwmServoContext = mraa_pwm_init (m_servoPin);
+    
+    m_currAngle = 180;
+    
+    setAngle (0);
 }
 
 Servo::~Servo () {
-
+    mraa_pwm_close (m_pwmServoContext);
 }
 
 /*
@@ -53,20 +62,32 @@ Servo::~Servo () {
  * Max period can be only 7968750(nses) which is ~8(msec)
  * so the servo wil not work as expected.
  * */
-maa_result_t Servo::setAngle (int angle) {
+mraa_result_t Servo::setAngle (int angle) {
     if (m_pwmServoContext == NULL) {
         std::cout << "PWM context is NULL" << std::endl;
-        return MAA_ERROR_UNSPECIFIED;
+        return MRAA_ERROR_UNSPECIFIED;
+    }
+    
+    if (angle > m_maxAngle || angle < 0) {
+        return MRAA_ERROR_UNSPECIFIED;
     }
 
-    maa_pwm_enable (m_pwmServoContext, 1);
-    for (int cycles = 0; cycles < 128; cycles++) {
-        maa_pwm_period_us (m_pwmServoContext, MAX_PERIOD);
-        maa_pwm_pulsewidth_us (m_pwmServoContext, calcPulseTraveling(angle));
-    }
-    maa_pwm_enable (m_pwmServoContext, 0);
+    int period = (m_maxPulseWidth - m_minPulseWidth) / m_maxAngle;
+    
+    int cycles = (int)(100.0 * (abs (m_currAngle - angle) / m_maxAngle));
 
-    std::cout << "angle = " << angle << " ,pulse = " << calcPulseTraveling(angle) << std::endl;
+    // int cycles = (int)(100.0 * ((float)angle / (float)m_maxAngle));
+
+    mraa_pwm_enable (m_pwmServoContext, 1);
+    for (int cycle = 0; cycle < cycles; cycle++) {
+        mraa_pwm_period_us (m_pwmServoContext, m_maxPeriod);
+        mraa_pwm_pulsewidth_us (m_pwmServoContext, calcPulseTraveling(angle));
+    }
+    mraa_pwm_enable (m_pwmServoContext, 0);
+
+    std::cout << "angle = " << angle << " ,pulse = " << calcPulseTraveling(angle) << ", cycles " << cycles << std::endl;
+    
+    m_currAngle = angle;
 }
 
 /*
@@ -75,14 +96,44 @@ maa_result_t Servo::setAngle (int angle) {
 int Servo::calcPulseTraveling (int value) {
     // if bigger than the boundaries
     if (value > m_maxAngle) {
-        return MAX_PULSE_WIDTH;
+        return m_maxPulseWidth;
     }
 
     // if less than the boundaries
     if (value  < 0) {
-        return MIN_PULSE_WIDTH;
+        return m_minPulseWidth;
     }
 
     // the conversion
-    return (int) ((float)MIN_PULSE_WIDTH + ((float)value / m_maxAngle) * ((float)MAX_PULSE_WIDTH - (float)MIN_PULSE_WIDTH));
+    return (int) ((float)m_minPulseWidth + ((float)value / m_maxAngle) * ((float)m_maxPulseWidth - (float)m_minPulseWidth));
+}
+
+void 
+Servo::setMinPulseWidth (int width) {
+    m_minPulseWidth = width;
+}
+
+void 
+Servo::setMaxPulseWidth (int width) {
+    m_maxPulseWidth = width;
+}
+
+void 
+Servo::setMaxPeriod (int width) {
+    m_maxPeriod = width;
+}
+
+int 
+Servo::getMinPulseWidth () {
+    return m_minPulseWidth;
+}
+    
+int 
+Servo::getMaxPulseWidth () {
+    return m_maxPulseWidth;
+}
+
+int 
+Servo::getMaxPeriod () {
+    return m_maxPeriod;
 }

src/servo/servo.h

@@ -24,7 +24,7 @@
 #pragma once
 
 #include <string>
-#include <maa/pwm.h>
+#include <mraa/pwm.h>
 
 namespace upm {
 
@@ -70,7 +70,7 @@ class Servo {
          *
          * @param angle number between 0 and 180
          */
-        maa_result_t setAngle (int angle);
+        mraa_result_t setAngle (int angle);
 
         /**
          * Return name of the component
@@ -79,14 +79,55 @@ class Servo {
         {
             return m_name;
         }
+        
+        /**
+         * Set min pulse width
+         *
+         * @param width HIGH signal width
+         */
+        void setMinPulseWidth (int width);
+        
+        /**
+         * Set max pulse width
+         *
+         * @param width HIGH signal width
+         */
+        void setMaxPulseWidth (int width);
+        
+        /**
+         * Set max period width
+         *
+         * @param width PWM period width
+         */
+        void setMaxPeriod (int width);
+        
+        /**
+         * Return min pulse width
+         */
+        int getMinPulseWidth ();
+        
+        /**
+         * Return max pulse width
+         */
+        int getMaxPulseWidth ();
+        
+        /**
+         * Return max PWM period width
+         */
+        int getMaxPeriod ();
+        
     protected:
         int calcPulseTraveling (int value);
 
         std::string         m_name;
         int                 m_servoPin;
         float               m_maxAngle;
-        maa_pwm_context     m_pwmServoContext;
-        // maa_gpio_context    m_servoPinCtx;
+        mraa_pwm_context     m_pwmServoContext;
+        int                 m_currAngle;
+        
+        int                 m_minPulseWidth;
+        int                 m_maxPulseWidth;
+        int                 m_maxPeriod;
 };
 
 }

src/st7735/CMakeLists.txt

@@ -0,0 +1,5 @@
+set (libname "st7735")
+set (libdescription "libupm SPI LCD")
+set (module_src gfx.cxx st7735.cxx)
+set (module_h gfx.h st7735.h)
+upm_module_init()

src/st7735/gfx.cxx

@@ -0,0 +1,231 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <iostream>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "gfx.h"
+
+using namespace upm;
+
+GFX::GFX (int width, int height, uint8_t * screenBuffer, const unsigned char * font) : WIDTH(width), HEIGHT(height) {
+    m_height = height;
+    m_width  = width;
+    m_font   = font;
+    m_map    = screenBuffer;
+}
+
+GFX::~GFX () {
+}
+
+mraa_result_t
+GFX::setPixel (int x, int y, uint16_t color) {
+    if((x < 0) ||(x >= m_width) || (y < 0) || (y >= m_height)) {
+        return MRAA_ERROR_UNSPECIFIED;
+    }
+
+    int index = ((y * m_width) + x) * sizeof(uint16_t);
+    m_map[index] = (uint8_t) (color >> 8);
+    m_map[++index] = (uint8_t)(color);
+
+    return MRAA_SUCCESS;
+}
+
+void
+GFX::fillScreen (uint16_t color) {
+    fillRect(0, 0, m_width, m_height, color);
+}
+
+void
+GFX::fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {
+    for (int16_t i=x; i<x+w; i++) {
+        drawFastVLine(i, y, h, color);
+    }
+}
+
+void
+GFX::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {
+    drawLine(x, y, x, y+h-1, color);
+}
+
+void
+GFX::drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
+    int16_t steep = abs(y1 - y0) > abs(x1 - x0);
+
+    if (steep) {
+        swap(x0, y0);
+        swap(x1, y1);
+    }
+
+    if (x0 > x1) {
+        swap(x0, x1);
+        swap(y0, y1);
+    }
+
+    int16_t dx, dy;
+    dx = x1 - x0;
+    dy = abs (y1 - y0);
+
+    int16_t err = dx / 2;
+    int16_t ystep;
+
+    if (y0 < y1) {
+        ystep = 1;
+    } else {
+        ystep = -1;
+    }
+
+    for (; x0 <= x1; x0++) {
+        if (steep) {
+            setPixel(y0, x0, color);
+        } else {
+            setPixel(x0, y0, color);
+        }
+        err -= dy;
+        if (err < 0) {
+            y0 += ystep;
+            err += dx;
+        }
+    }
+}
+
+void
+GFX::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
+    drawLine(x0, y0, x1, y1, color);
+    drawLine(x1, y1, x2, y2, color);
+    drawLine(x2, y2, x0, y0, color);
+}
+
+void
+GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
+    int16_t f = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x = 0;
+    int16_t y = r;
+
+    setPixel(x0  , y0+r, color);
+    setPixel(x0  , y0-r, color);
+    setPixel(x0+r, y0  , color);
+    setPixel(x0-r, y0  , color);
+
+    while (x<y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+
+        ddF_x += 2;
+        f += ddF_x;
+
+        setPixel(x0 + x, y0 + y, color);
+        setPixel(x0 - x, y0 + y, color);
+        setPixel(x0 + x, y0 - y, color);
+        setPixel(x0 - x, y0 - y, color);
+        setPixel(x0 + y, y0 + x, color);
+        setPixel(x0 - y, y0 + x, color);
+        setPixel(x0 + y, y0 - x, color);
+        setPixel(x0 - y, y0 - x, color);
+    }
+}
+
+void
+GFX::setCursor (int16_t x, int16_t y) {
+    m_cursorX = x;
+    m_cursorY = y;
+}
+
+void
+GFX::setTextColor (uint16_t textColor, uint16_t textBGColor) {
+    m_textColor   = textColor;
+    m_textBGColor = textBGColor;
+}
+
+void
+GFX::setTextSize (uint8_t size) {
+    m_textSize = (size > 0) ? size : 1;
+}
+
+void
+GFX::setTextWrap (uint8_t wrap) {
+    m_wrap = wrap;
+}
+
+void
+GFX::drawChar (int16_t x, int16_t y, uint8_t data, uint16_t color, uint16_t bg, uint8_t size) {
+    if( (x >= m_width)            || // Clip right
+        (y >= m_height)           || // Clip bottom
+        ((x + 6 * size - 1) < 0)  || // Clip left
+        ((y + 8 * size - 1) < 0))    // Clip top
+    return;
+
+    for (int8_t i=0; i<6; i++ ) {
+        uint8_t line;
+        if (i == 5) {
+            line = 0x0;
+        } else {
+            line = *(m_font+(data * 5)+i);
+            for (int8_t j = 0; j<8; j++) {
+                if (line & 0x1) {
+                    if (size == 1) // default size
+                        setPixel (x+i, y+j, color);
+                    else {  // big size
+                        fillRect (x+(i*size), y+(j*size), size, size, color);
+                    }
+                } else if (bg != color) {
+                    if (size == 1) // default size
+                        setPixel (x+i, y+j, bg);
+                    else {  // big size
+                        fillRect (x+i*size, y+j*size, size, size, bg);
+                    }
+                }
+                line >>= 1;
+            }
+        }
+    }
+}
+
+void
+GFX::print (std::string msg) {
+    int len = msg.length();
+
+    for (int idx = 0; idx < len; idx++) {
+        if (msg[idx] == '\n') {
+            m_cursorY += m_textSize * 8;
+            m_cursorX  = 0;
+        } else if (msg[idx] == '\r') {
+            // skip em
+        } else {
+            drawChar(m_cursorX, m_cursorY, msg[idx], m_textColor, m_textBGColor, m_textSize);
+            m_cursorX += m_textSize * 6;
+            if (m_wrap && (m_textColor > (m_width - m_textSize * 6))) {
+                m_cursorY += m_textSize * 8;
+                m_cursorX = 0;
+            }
+        }
+    }
+}

src/st7735/gfx.h

@@ -0,0 +1,216 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <mraa.h>
+
+#define swap(a, b) { int16_t t = a; a = b; b = t; }
+
+namespace upm {
+
+/**
+ * @brief GFX helper class
+ *
+ * This file used by the screen.
+ */
+class GFX {
+    public:
+        /**
+         * Instanciates a GFX object
+         *
+         * @param width screen width
+         * @param height screen height
+         * @param screenBuffer pointer to screen buffer
+         * @param font pointer to font map
+         */
+        GFX (int width, int height, uint8_t * screenBuffer, const unsigned char * font);
+
+        /**
+         * GFX object destructor
+         */
+        ~GFX ();
+
+        /**
+         * Set the window address
+         *
+         * @param x0 first coordinate
+         * @param y0 first coordinate
+         * @param x1 second coordinate
+         * @param y1 second coordinate
+         */
+        virtual void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) = 0;
+
+        /**
+         * Send pixel collor (RGB) to the chip. Must be implemented by
+         * inherited class.
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param color rgb value
+         */
+        virtual void drawPixel (int16_t x, int16_t y, uint16_t color) = 0;
+
+        /**
+         * Copy the buffer to the chip via SPI interface.
+         */
+        virtual void refresh () = 0;
+
+        /**
+         *
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param data character to write
+         * @param color character's color
+         * @param bg character's background color
+         * @param size size of the font
+         */
+        void drawChar (int16_t x, int16_t y, uint8_t data, uint16_t color, uint16_t bg, uint8_t size);
+
+        /**
+         * Print the message to the screen
+         *
+         * @param msg message which will be printed
+         */
+        void print (std::string msg);
+
+        /**
+         * Print the message to the screen
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param color pixel's color
+         */
+        mraa_result_t setPixel (int x, int y, uint16_t color);
+
+        /**
+         * Fill screen with selected color
+         *
+         * @param color selected's color
+         */
+        void fillScreen (uint16_t color);
+
+        /**
+         * Fill rectangle with selected color
+         *
+         * @param x axis on horizontal scale (top left corner)
+         * @param y axis on vertical scale (top left corner)
+         * @param w distanse from x
+         * @param h distanse from y
+         * @param color selected color
+         */
+        void fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
+
+        /**
+         * Draw line in vertical scale.
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param h distanse from y
+         * @param color selected color
+         */
+        void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+
+        /**
+         * Draw line from coordinate C0 to coordinate C1
+         *
+         * @param x0 first coordinate
+         * @param y0 first coordinate
+         * @param x1 second coordinate
+         * @param y1 second coordinate
+         * @param color selected color
+         */
+        void drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
+
+        /**
+         * Draw a triangle
+         *
+         * @param x0 first coordinate
+         * @param y0 first coordinate
+         * @param x1 second coordinate
+         * @param y1 second coordinate
+         * @param x2 third coordinate
+         * @param y2 third coordinate
+         * @param color selected color
+         */
+        void drawTriangle (int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
+
+        /**
+         * Draw a circle
+         *
+         * @param x center of circule on X scale
+         * @param y center of circule on Y scale
+         */
+        void drawCircle (int16_t x, int16_t y, int16_t r, uint16_t color);
+
+        /**
+         * Set cursor for text message
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         */
+        void setCursor (int16_t x, int16_t y);
+
+        /**
+         * Set text color for the message
+         *
+         * @param textColor font color
+         * @param textBGColor background color
+         */
+        void setTextColor (uint16_t textColor, uint16_t textBGColor);
+
+        /**
+         * Set the size of the font
+         *
+         * @param size font size
+         */
+        void setTextSize (uint8_t size);
+
+        /**
+         * Wrap printed message.
+         *
+         * @param wrap true (0x1) or false (0x0)
+         */
+        void setTextWrap (uint8_t wrap);
+
+        int m_height; /**< Screen height */
+        int m_width; /**< Screen width */
+        int m_textSize; /**< Printed text size */
+        int m_textColor; /**< Printed text color */
+        int m_textBGColor; /**< Printed text background color */
+        int m_cursorX; /**< Cursor X coordinate */
+        int m_cursorY; /**< Cursor Y coordinate */
+        int m_wrap; /**< Wrapper flag (true or false) */
+
+        uint8_t * m_map; /**< Screens buffer */
+
+    protected:
+        const int16_t   WIDTH, HEIGHT;
+        const unsigned char * m_font;
+    };
+}

src/st7735/jsupm_st7735.i

@@ -0,0 +1,7 @@
+%module jsupm_st7735
+
+%{
+    #include "st7735.h"
+%}
+
+%include "st7735.h"

src/st7735/license.txt

@@ -0,0 +1,24 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2012 Adafruit Industries.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

src/st7735/pyupm_st7735.i

@@ -0,0 +1,8 @@
+%module pyupm_st7735
+
+%feature("autodoc", "3");
+
+%include "st7735.h"
+%{
+    #include "st7735.h"
+%}

src/st7735/st7735.cxx

@@ -0,0 +1,319 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <iostream>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "st7735.h"
+
+using namespace upm;
+
+ST7735::ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst) : GFX (160, 128, m_map, font) {
+    mraa_init();
+
+    m_csLCD = csLCD;
+    m_cSD   = cSD;
+    m_rST   = rst;
+    m_rS    = rs;
+
+    initModule ();
+    configModule ();
+}
+
+ST7735::~ST7735 () {
+    mraa_result_t error = MRAA_SUCCESS;
+    error = mraa_spi_stop(m_spi);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+    error = mraa_gpio_close (m_csLCDPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+    error = mraa_gpio_close (m_cSDPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+    error = mraa_gpio_close (m_rSTPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+    error = mraa_gpio_close (m_rSPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+}
+
+void
+ST7735::initModule () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    m_height = 160;
+    m_width  = 128;
+
+    m_csLCDPinCtx = mraa_gpio_init (m_csLCD);
+    if (m_csLCDPinCtx == NULL) {
+        fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_csLCD);
+        exit (1);
+    }
+
+    m_cSDPinCtx = mraa_gpio_init (m_cSD);
+    if (m_cSDPinCtx == NULL) {
+        fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_cSD);
+        exit (1);
+    }
+
+    m_rSTPinCtx = mraa_gpio_init (m_rST);
+    if (m_rSTPinCtx == NULL) {
+        fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rST);
+        exit (1);
+    }
+
+    m_rSPinCtx = mraa_gpio_init (m_rS);
+    if (m_rSPinCtx == NULL) {
+        fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rS);
+        exit (1);
+    }
+
+    error = mraa_gpio_dir (m_csLCDPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    error = mraa_gpio_dir (m_cSDPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    error = mraa_gpio_dir (m_rSTPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    error = mraa_gpio_dir (m_rSPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    m_spi = mraa_spi_init (0);
+    error = mraa_spi_frequency(m_spi, 15 * 1000000);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    lcdCSOn ();
+}
+
+void
+ST7735::write (uint8_t value) {
+    rsLOW ();
+    mraa_spi_write (m_spi, value);
+}
+
+void
+ST7735::data (uint8_t value) {
+    rsHIGH ();
+    mraa_spi_write (m_spi, value);
+}
+
+void
+ST7735::executeCMDList(const uint8_t *addr) {
+    uint8_t  numCommands, numArgs;
+    uint16_t ms;
+
+    numCommands = *(addr++);           // Number of commands to follow
+    while(numCommands--) {             // For each command...
+        write (*(addr++));             // Read, issue command
+        numArgs  = *(addr++);          // Number of args to follow
+        ms       = numArgs & DELAY;    // If hibit set, delay follows args
+        numArgs &= ~DELAY;             // Mask out delay bit
+        while(numArgs--) {             // For each argument...
+            data (*(addr++));          // Read, issue argument
+        }
+
+        if(ms) {
+            ms = *(addr++);            // Read post-command delay time (ms)
+            if (ms == 255) {
+                ms = 500;              // If 255, delay for 500 ms
+            }
+            usleep (ms * 1000);
+        }
+    }
+}
+
+void
+ST7735::setAddrWindow(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) {
+    uint8_t colstart, rowstart;
+    colstart  = rowstart = 0;
+
+    write (ST7735_CASET);                       // Column addr set
+
+    rsHIGH ();
+    m_spiBuffer[0] = 0x00;
+    m_spiBuffer[1] = x0 + colstart;             // XSTART
+    m_spiBuffer[2] = 0x00;
+    m_spiBuffer[3] = x1 + colstart;             // XEND
+    mraa_spi_write_buf(m_spi, m_spiBuffer, 4);
+
+    write (ST7735_RASET);                       // Row addr set
+
+    rsHIGH ();
+    m_spiBuffer[0] = 0x00;
+    m_spiBuffer[1] = y0 + rowstart;             // YSTART
+    m_spiBuffer[2] = 0x00;
+    m_spiBuffer[3] = y1 + rowstart;             // YEND
+    mraa_spi_write_buf(m_spi, m_spiBuffer, 4);
+
+    write (ST7735_RAMWR);                       // write to RAM
+}
+
+void
+ST7735::drawPixel(int16_t x, int16_t y, uint16_t color) {
+    if (MRAA_SUCCESS != setPixel (x, y, color)) {
+        return;
+    }
+
+    refresh ();
+}
+
+void
+ST7735::refresh () {
+    rsHIGH ();
+
+    int fragmentSize = m_height * m_width * 2 / 20;
+    for (int fragment = 0; fragment < 20; fragment++) {
+        mraa_spi_write_buf(m_spi, &m_map[fragment * fragmentSize], fragmentSize);
+    }
+}
+
+void
+ST7735::configModule() {
+    rsHIGH ();
+    lcdCSOff ();
+    lcdCSOn ();
+
+    mraa_gpio_write (m_rSTPinCtx, HIGH);
+    usleep (500000);
+    mraa_gpio_write (m_rSTPinCtx, LOW);
+    usleep (500000);
+    mraa_gpio_write (m_rSTPinCtx, HIGH);
+    usleep (500000);
+
+    executeCMDList (Rcmd1);
+    executeCMDList (Rcmd2red);
+    executeCMDList (Rcmd3);
+
+    write (ST7735_MADCTL);
+    data (0xC0);
+
+    setAddrWindow (0, 0, m_width - 1, m_height - 1);
+
+    fillScreen (ST7735_BLACK);
+    refresh ();
+}
+
+mraa_result_t
+ST7735::lcdCSOn () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_csLCDPinCtx, LOW);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    error = mraa_gpio_write (m_cSDPinCtx, HIGH);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}
+
+mraa_result_t
+ST7735::lcdCSOff () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_csLCDPinCtx, HIGH);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}
+
+mraa_result_t
+ST7735::sdCSOn () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_cSDPinCtx, LOW);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    error = mraa_gpio_write (m_csLCDPinCtx, HIGH);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}
+
+mraa_result_t
+ST7735::sdCSOff () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_cSDPinCtx, HIGH);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}
+
+mraa_result_t
+ST7735::rsHIGH () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_rSPinCtx, HIGH);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}
+
+mraa_result_t
+ST7735::rsLOW () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_rSPinCtx, LOW);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}

src/st7735/st7735.h

@@ -0,0 +1,632 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Credits to Adafruit.
+ * Based on Adafruit ST7735 library, see original license in license.txt file.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
+#include <mraa/spi.h>
+#include <gfx.h>
+
+#define INITR_GREENTAB      0x0
+#define INITR_REDTAB        0x1
+#define INITR_BLACKTAB      0x2
+
+#define ST7735_TFTWIDTH     128
+#define ST7735_TFTHEIGHT    160
+
+#define ST7735_NOP          0x00
+#define ST7735_SWRESET      0x01
+#define ST7735_RDDID        0x04
+#define ST7735_RDDST        0x09
+
+#define ST7735_SLPIN        0x10
+#define ST7735_SLPOUT       0x11
+#define ST7735_PTLON        0x12
+#define ST7735_NORON        0x13
+
+#define ST7735_INVOFF       0x20
+#define ST7735_INVON        0x21
+#define ST7735_DISPOFF      0x28
+#define ST7735_DISPON       0x29
+#define ST7735_CASET        0x2A
+#define ST7735_RASET        0x2B
+#define ST7735_RAMWR        0x2C
+#define ST7735_RAMRD        0x2E
+
+#define ST7735_PTLAR        0x30
+#define ST7735_COLMOD       0x3A
+#define ST7735_MADCTL       0x36
+
+#define ST7735_FRMCTR1      0xB1
+#define ST7735_FRMCTR2      0xB2
+#define ST7735_FRMCTR3      0xB3
+#define ST7735_INVCTR       0xB4
+#define ST7735_DISSET5      0xB6
+
+#define ST7735_PWCTR1       0xC0
+#define ST7735_PWCTR2       0xC1
+#define ST7735_PWCTR3       0xC2
+#define ST7735_PWCTR4       0xC3
+#define ST7735_PWCTR5       0xC4
+#define ST7735_VMCTR1       0xC5
+
+#define ST7735_RDID1        0xDA
+#define ST7735_RDID2        0xDB
+#define ST7735_RDID3        0xDC
+#define ST7735_RDID4        0xDD
+
+#define ST7735_PWCTR6       0xFC
+
+#define ST7735_GMCTRP1      0xE0
+#define ST7735_GMCTRN1      0xE1
+
+// Color definitions
+#define ST7735_BLACK        0x0000
+#define ST7735_BLUE         0x001F
+#define ST7735_RED          0xF800
+#define ST7735_GREEN        0x07E0
+#define ST7735_CYAN         0x07FF
+#define ST7735_MAGENTA      0xF81F
+#define ST7735_YELLOW       0xFFE0
+#define ST7735_WHITE        0xFFFF
+
+#define HIGH                1
+#define LOW                 0
+
+#define DELAY               0x80
+
+namespace upm {
+
+static const uint8_t Bcmd[] = {
+    // Initialization commands for 7735B screens
+      18,                     // 18 commands in list:
+    ST7735_SWRESET,   DELAY,  //  1: Software reset, no args, w/delay
+      50,                     //     50 ms delay
+    ST7735_SLPOUT ,   DELAY,  //  2: Out of sleep mode, no args, w/delay
+      255,                    //     255 = 500 ms delay
+    ST7735_COLMOD , 1+DELAY,  //  3: Set color mode, 1 arg + delay:
+      0x05,                   //     16-bit color
+      10,                     //     10 ms delay
+    ST7735_FRMCTR1, 3+DELAY,  //  4: Frame rate control, 3 args + delay:
+      0x00,                   //     fastest refresh
+      0x06,                   //     6 lines front porch
+      0x03,                   //     3 lines back porch
+      10,                     //     10 ms delay
+    ST7735_MADCTL , 1      ,  //  5: Memory access ctrl (directions), 1 arg:
+      0x08,                   //     Row addr/col addr, bottom to top refresh
+    ST7735_DISSET5, 2      ,  //  6: Display settings #5, 2 args, no delay:
+      0x15,                   //     1 clk cycle nonoverlap, 2 cycle gate
+                              //     rise, 3 cycle osc equalize
+      0x02,                   //     Fix on VTL
+    ST7735_INVCTR , 1      ,  //  7: Display inversion control, 1 arg:
+      0x0,                    //     Line inversion
+    ST7735_PWCTR1 , 2+DELAY,  //  8: Power control, 2 args + delay:
+      0x02,                   //     GVDD = 4.7V
+      0x70,                   //     1.0uA
+      10,                     //     10 ms delay
+    ST7735_PWCTR2 , 1      ,  //  9: Power control, 1 arg, no delay:
+      0x05,                   //     VGH = 14.7V, VGL = -7.35V
+    ST7735_PWCTR3 , 2      ,  // 10: Power control, 2 args, no delay:
+      0x01,                   //     Opamp current small
+      0x02,                   //     Boost frequency
+    ST7735_VMCTR1 , 2+DELAY,  // 11: Power control, 2 args + delay:
+      0x3C,                   //     VCOMH = 4V
+      0x38,                   //     VCOML = -1.1V
+      10,                     //     10 ms delay
+    ST7735_PWCTR6 , 2      ,  // 12: Power control, 2 args, no delay:
+      0x11, 0x15,
+    ST7735_GMCTRP1,16      ,  // 13: Magical unicorn dust, 16 args, no delay:
+      0x09, 0x16, 0x09, 0x20, //     (seriously though, not sure what
+      0x21, 0x1B, 0x13, 0x19, //      these config values represent)
+      0x17, 0x15, 0x1E, 0x2B,
+      0x04, 0x05, 0x02, 0x0E,
+    ST7735_GMCTRN1,16+DELAY,  // 14: Sparkles and rainbows, 16 args + delay:
+      0x0B, 0x14, 0x08, 0x1E, //     (ditto)
+      0x22, 0x1D, 0x18, 0x1E,
+      0x1B, 0x1A, 0x24, 0x2B,
+      0x06, 0x06, 0x02, 0x0F,
+      10,                     //     10 ms delay
+    ST7735_CASET  , 4      ,  // 15: Column addr set, 4 args, no delay:
+      0x00, 0x02,             //     XSTART = 2
+      0x00, 0x81,             //     XEND = 129
+    ST7735_RASET  , 4      ,  // 16: Row addr set, 4 args, no delay:
+      0x00, 0x02,             //     XSTART = 1
+      0x00, 0x81,             //     XEND = 160
+    ST7735_NORON  ,   DELAY,  // 17: Normal display on, no args, w/delay
+      10,                     //     10 ms delay
+    ST7735_DISPON ,   DELAY,  // 18: Main screen turn on, no args, w/delay
+      255 },                  //     255 = 500 ms delay
+
+  Rcmd1[] = {                 // Init for 7735R, part 1 (red or green tab)
+      15,                     // 15 commands in list:
+    ST7735_SWRESET,   DELAY,  //  1: Software reset, 0 args, w/delay
+      150,                    //     150 ms delay
+    ST7735_SLPOUT ,   DELAY,  //  2: Out of sleep mode, 0 args, w/delay
+      255,                    //     500 ms delay
+    ST7735_FRMCTR1, 3      ,  //  3: Frame rate ctrl - normal mode, 3 args:
+      0x01, 0x2C, 0x2D,       //     Rate = fosc/(1x2+40) * (LINE+2C+2D)
+    ST7735_FRMCTR2, 3      ,  //  4: Frame rate control - idle mode, 3 args:
+      0x01, 0x2C, 0x2D,       //     Rate = fosc/(1x2+40) * (LINE+2C+2D)
+    ST7735_FRMCTR3, 6      ,  //  5: Frame rate ctrl - partial mode, 6 args:
+      0x01, 0x2C, 0x2D,       //     Dot inversion mode
+      0x01, 0x2C, 0x2D,       //     Line inversion mode
+    ST7735_INVCTR , 1      ,  //  6: Display inversion ctrl, 1 arg, no delay:
+      0x07,                   //     No inversion
+    ST7735_PWCTR1 , 3      ,  //  7: Power control, 3 args, no delay:
+      0xA2,
+      0x02,                   //     -4.6V
+      0x84,                   //     AUTO mode
+    ST7735_PWCTR2 , 1      ,  //  8: Power control, 1 arg, no delay:
+      0xC5,                   //     VGH25 = 2.4C VGSEL = -10 VGH = 3 * AVDD
+    ST7735_PWCTR3 , 2      ,  //  9: Power control, 2 args, no delay:
+      0x0A,                   //     Opamp current small
+      0x00,                   //     Boost frequency
+    ST7735_PWCTR4 , 2      ,  // 10: Power control, 2 args, no delay:
+      0x8A,                   //     BCLK/2, Opamp current small & Medium low
+      0x2A,
+    ST7735_PWCTR5 , 2      ,  // 11: Power control, 2 args, no delay:
+      0x8A, 0xEE,
+    ST7735_VMCTR1 , 1      ,  // 12: Power control, 1 arg, no delay:
+      0x0E,
+    ST7735_INVOFF , 0      ,  // 13: Don't invert display, no args, no delay
+    ST7735_MADCTL , 1      ,  // 14: Memory access control (directions), 1 arg:
+      0xC8,                   //     row addr/col addr, bottom to top refresh
+    ST7735_COLMOD , 1      ,  // 15: set color mode, 1 arg, no delay:
+      0x05 },                 //     16-bit color
+
+  Rcmd2green[] = {            // Init for 7735R, part 2 (green tab only)
+      2,                      //  2 commands in list:
+    ST7735_CASET  , 4      ,  //  1: Column addr set, 4 args, no delay:
+      0x00, 0x02,             //     XSTART = 0
+      0x00, 0x7F+0x02,        //     XEND = 127
+    ST7735_RASET  , 4      ,  //  2: Row addr set, 4 args, no delay:
+      0x00, 0x01,             //     XSTART = 0
+      0x00, 0x9F+0x01 },      //     XEND = 159
+  Rcmd2red[] = {              // Init for 7735R, part 2 (red tab only)
+      2,                      //  2 commands in list:
+    ST7735_CASET  , 4      ,  //  1: Column addr set, 4 args, no delay:
+      0x00, 0x00,             //     XSTART = 0
+      0x00, 0x7F,             //     XEND = 127
+    ST7735_RASET  , 4      ,  //  2: Row addr set, 4 args, no delay:
+      0x00, 0x00,             //     XSTART = 0
+      0x00, 0x9F },           //     XEND = 159
+
+  Rcmd3[] = {                 // Init for 7735R, part 3 (red or green tab)
+      4,                      //  4 commands in list:
+    ST7735_GMCTRP1, 16      , //  1: Magical unicorn dust, 16 args, no delay:
+      0x02, 0x1c, 0x07, 0x12,
+      0x37, 0x32, 0x29, 0x2d,
+      0x29, 0x25, 0x2B, 0x39,
+      0x00, 0x01, 0x03, 0x10,
+    ST7735_GMCTRN1, 16      , //  2: Sparkles and rainbows, 16 args, no delay:
+      0x03, 0x1d, 0x07, 0x06,
+      0x2E, 0x2C, 0x29, 0x2D,
+      0x2E, 0x2E, 0x37, 0x3F,
+      0x00, 0x00, 0x02, 0x10,
+    ST7735_NORON  ,    DELAY, //  3: Normal display on, no args, w/delay
+      10,                     //     10 ms delay
+    ST7735_DISPON ,    DELAY, //  4: Main screen turn on, no args w/delay
+      100 };                  //     100 ms delay
+
+#define swap(a, b) { int16_t t = a; a = b; b = t; }
+
+const unsigned char font[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
+    0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
+    0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
+    0x18, 0x3C, 0x7E, 0x3C, 0x18,
+    0x1C, 0x57, 0x7D, 0x57, 0x1C,
+    0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
+    0x00, 0x18, 0x3C, 0x18, 0x00,
+    0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
+    0x00, 0x18, 0x24, 0x18, 0x00,
+    0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
+    0x30, 0x48, 0x3A, 0x06, 0x0E,
+    0x26, 0x29, 0x79, 0x29, 0x26,
+    0x40, 0x7F, 0x05, 0x05, 0x07,
+    0x40, 0x7F, 0x05, 0x25, 0x3F,
+    0x5A, 0x3C, 0xE7, 0x3C, 0x5A,
+    0x7F, 0x3E, 0x1C, 0x1C, 0x08,
+    0x08, 0x1C, 0x1C, 0x3E, 0x7F,
+    0x14, 0x22, 0x7F, 0x22, 0x14,
+    0x5F, 0x5F, 0x00, 0x5F, 0x5F,
+    0x06, 0x09, 0x7F, 0x01, 0x7F,
+    0x00, 0x66, 0x89, 0x95, 0x6A,
+    0x60, 0x60, 0x60, 0x60, 0x60,
+    0x94, 0xA2, 0xFF, 0xA2, 0x94,
+    0x08, 0x04, 0x7E, 0x04, 0x08,
+    0x10, 0x20, 0x7E, 0x20, 0x10,
+    0x08, 0x08, 0x2A, 0x1C, 0x08,
+    0x08, 0x1C, 0x2A, 0x08, 0x08,
+    0x1E, 0x10, 0x10, 0x10, 0x10,
+    0x0C, 0x1E, 0x0C, 0x1E, 0x0C,
+    0x30, 0x38, 0x3E, 0x38, 0x30,
+    0x06, 0x0E, 0x3E, 0x0E, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x5F, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x07, 0x00,
+    0x14, 0x7F, 0x14, 0x7F, 0x14,
+    0x24, 0x2A, 0x7F, 0x2A, 0x12,
+    0x23, 0x13, 0x08, 0x64, 0x62,
+    0x36, 0x49, 0x56, 0x20, 0x50,
+    0x00, 0x08, 0x07, 0x03, 0x00,
+    0x00, 0x1C, 0x22, 0x41, 0x00,
+    0x00, 0x41, 0x22, 0x1C, 0x00,
+    0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
+    0x08, 0x08, 0x3E, 0x08, 0x08,
+    0x00, 0x80, 0x70, 0x30, 0x00,
+    0x08, 0x08, 0x08, 0x08, 0x08,
+    0x00, 0x00, 0x60, 0x60, 0x00,
+    0x20, 0x10, 0x08, 0x04, 0x02,
+    0x3E, 0x51, 0x49, 0x45, 0x3E,
+    0x00, 0x42, 0x7F, 0x40, 0x00,
+    0x72, 0x49, 0x49, 0x49, 0x46,
+    0x21, 0x41, 0x49, 0x4D, 0x33,
+    0x18, 0x14, 0x12, 0x7F, 0x10,
+    0x27, 0x45, 0x45, 0x45, 0x39,
+    0x3C, 0x4A, 0x49, 0x49, 0x31,
+    0x41, 0x21, 0x11, 0x09, 0x07,
+    0x36, 0x49, 0x49, 0x49, 0x36,
+    0x46, 0x49, 0x49, 0x29, 0x1E,
+    0x00, 0x00, 0x14, 0x00, 0x00,
+    0x00, 0x40, 0x34, 0x00, 0x00,
+    0x00, 0x08, 0x14, 0x22, 0x41,
+    0x14, 0x14, 0x14, 0x14, 0x14,
+    0x00, 0x41, 0x22, 0x14, 0x08,
+    0x02, 0x01, 0x59, 0x09, 0x06,
+    0x3E, 0x41, 0x5D, 0x59, 0x4E,
+    0x7C, 0x12, 0x11, 0x12, 0x7C,
+    0x7F, 0x49, 0x49, 0x49, 0x36,
+    0x3E, 0x41, 0x41, 0x41, 0x22,
+    0x7F, 0x41, 0x41, 0x41, 0x3E,
+    0x7F, 0x49, 0x49, 0x49, 0x41,
+    0x7F, 0x09, 0x09, 0x09, 0x01,
+    0x3E, 0x41, 0x41, 0x51, 0x73,
+    0x7F, 0x08, 0x08, 0x08, 0x7F,
+    0x00, 0x41, 0x7F, 0x41, 0x00,
+    0x20, 0x40, 0x41, 0x3F, 0x01,
+    0x7F, 0x08, 0x14, 0x22, 0x41,
+    0x7F, 0x40, 0x40, 0x40, 0x40,
+    0x7F, 0x02, 0x1C, 0x02, 0x7F,
+    0x7F, 0x04, 0x08, 0x10, 0x7F,
+    0x3E, 0x41, 0x41, 0x41, 0x3E,
+    0x7F, 0x09, 0x09, 0x09, 0x06,
+    0x3E, 0x41, 0x51, 0x21, 0x5E,
+    0x7F, 0x09, 0x19, 0x29, 0x46,
+    0x26, 0x49, 0x49, 0x49, 0x32,
+    0x03, 0x01, 0x7F, 0x01, 0x03,
+    0x3F, 0x40, 0x40, 0x40, 0x3F,
+    0x1F, 0x20, 0x40, 0x20, 0x1F,
+    0x3F, 0x40, 0x38, 0x40, 0x3F,
+    0x63, 0x14, 0x08, 0x14, 0x63,
+    0x03, 0x04, 0x78, 0x04, 0x03,
+    0x61, 0x59, 0x49, 0x4D, 0x43,
+    0x00, 0x7F, 0x41, 0x41, 0x41,
+    0x02, 0x04, 0x08, 0x10, 0x20,
+    0x00, 0x41, 0x41, 0x41, 0x7F,
+    0x04, 0x02, 0x01, 0x02, 0x04,
+    0x40, 0x40, 0x40, 0x40, 0x40,
+    0x00, 0x03, 0x07, 0x08, 0x00,
+    0x20, 0x54, 0x54, 0x78, 0x40,
+    0x7F, 0x28, 0x44, 0x44, 0x38,
+    0x38, 0x44, 0x44, 0x44, 0x28,
+    0x38, 0x44, 0x44, 0x28, 0x7F,
+    0x38, 0x54, 0x54, 0x54, 0x18,
+    0x00, 0x08, 0x7E, 0x09, 0x02,
+    0x18, 0xA4, 0xA4, 0x9C, 0x78,
+    0x7F, 0x08, 0x04, 0x04, 0x78,
+    0x00, 0x44, 0x7D, 0x40, 0x00,
+    0x20, 0x40, 0x40, 0x3D, 0x00,
+    0x7F, 0x10, 0x28, 0x44, 0x00,
+    0x00, 0x41, 0x7F, 0x40, 0x00,
+    0x7C, 0x04, 0x78, 0x04, 0x78,
+    0x7C, 0x08, 0x04, 0x04, 0x78,
+    0x38, 0x44, 0x44, 0x44, 0x38,
+    0xFC, 0x18, 0x24, 0x24, 0x18,
+    0x18, 0x24, 0x24, 0x18, 0xFC,
+    0x7C, 0x08, 0x04, 0x04, 0x08,
+    0x48, 0x54, 0x54, 0x54, 0x24,
+    0x04, 0x04, 0x3F, 0x44, 0x24,
+    0x3C, 0x40, 0x40, 0x20, 0x7C,
+    0x1C, 0x20, 0x40, 0x20, 0x1C,
+    0x3C, 0x40, 0x30, 0x40, 0x3C,
+    0x44, 0x28, 0x10, 0x28, 0x44,
+    0x4C, 0x90, 0x90, 0x90, 0x7C,
+    0x44, 0x64, 0x54, 0x4C, 0x44,
+    0x00, 0x08, 0x36, 0x41, 0x00,
+    0x00, 0x00, 0x77, 0x00, 0x00,
+    0x00, 0x41, 0x36, 0x08, 0x00,
+    0x02, 0x01, 0x02, 0x04, 0x02,
+    0x3C, 0x26, 0x23, 0x26, 0x3C,
+    0x1E, 0xA1, 0xA1, 0x61, 0x12,
+    0x3A, 0x40, 0x40, 0x20, 0x7A,
+    0x38, 0x54, 0x54, 0x55, 0x59,
+    0x21, 0x55, 0x55, 0x79, 0x41,
+    0x21, 0x54, 0x54, 0x78, 0x41,
+    0x21, 0x55, 0x54, 0x78, 0x40,
+    0x20, 0x54, 0x55, 0x79, 0x40,
+    0x0C, 0x1E, 0x52, 0x72, 0x12,
+    0x39, 0x55, 0x55, 0x55, 0x59,
+    0x39, 0x54, 0x54, 0x54, 0x59,
+    0x39, 0x55, 0x54, 0x54, 0x58,
+    0x00, 0x00, 0x45, 0x7C, 0x41,
+    0x00, 0x02, 0x45, 0x7D, 0x42,
+    0x00, 0x01, 0x45, 0x7C, 0x40,
+    0xF0, 0x29, 0x24, 0x29, 0xF0,
+    0xF0, 0x28, 0x25, 0x28, 0xF0,
+    0x7C, 0x54, 0x55, 0x45, 0x00,
+    0x20, 0x54, 0x54, 0x7C, 0x54,
+    0x7C, 0x0A, 0x09, 0x7F, 0x49,
+    0x32, 0x49, 0x49, 0x49, 0x32,
+    0x32, 0x48, 0x48, 0x48, 0x32,
+    0x32, 0x4A, 0x48, 0x48, 0x30,
+    0x3A, 0x41, 0x41, 0x21, 0x7A,
+    0x3A, 0x42, 0x40, 0x20, 0x78,
+    0x00, 0x9D, 0xA0, 0xA0, 0x7D,
+    0x39, 0x44, 0x44, 0x44, 0x39,
+    0x3D, 0x40, 0x40, 0x40, 0x3D,
+    0x3C, 0x24, 0xFF, 0x24, 0x24,
+    0x48, 0x7E, 0x49, 0x43, 0x66,
+    0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
+    0xFF, 0x09, 0x29, 0xF6, 0x20,
+    0xC0, 0x88, 0x7E, 0x09, 0x03,
+    0x20, 0x54, 0x54, 0x79, 0x41,
+    0x00, 0x00, 0x44, 0x7D, 0x41,
+    0x30, 0x48, 0x48, 0x4A, 0x32,
+    0x38, 0x40, 0x40, 0x22, 0x7A,
+    0x00, 0x7A, 0x0A, 0x0A, 0x72,
+    0x7D, 0x0D, 0x19, 0x31, 0x7D,
+    0x26, 0x29, 0x29, 0x2F, 0x28,
+    0x26, 0x29, 0x29, 0x29, 0x26,
+    0x30, 0x48, 0x4D, 0x40, 0x20,
+    0x38, 0x08, 0x08, 0x08, 0x08,
+    0x08, 0x08, 0x08, 0x08, 0x38,
+    0x2F, 0x10, 0xC8, 0xAC, 0xBA,
+    0x2F, 0x10, 0x28, 0x34, 0xFA,
+    0x00, 0x00, 0x7B, 0x00, 0x00,
+    0x08, 0x14, 0x2A, 0x14, 0x22,
+    0x22, 0x14, 0x2A, 0x14, 0x08,
+    0xAA, 0x00, 0x55, 0x00, 0xAA,
+    0xAA, 0x55, 0xAA, 0x55, 0xAA,
+    0x00, 0x00, 0x00, 0xFF, 0x00,
+    0x10, 0x10, 0x10, 0xFF, 0x00,
+    0x14, 0x14, 0x14, 0xFF, 0x00,
+    0x10, 0x10, 0xFF, 0x00, 0xFF,
+    0x10, 0x10, 0xF0, 0x10, 0xF0,
+    0x14, 0x14, 0x14, 0xFC, 0x00,
+    0x14, 0x14, 0xF7, 0x00, 0xFF,
+    0x00, 0x00, 0xFF, 0x00, 0xFF,
+    0x14, 0x14, 0xF4, 0x04, 0xFC,
+    0x14, 0x14, 0x17, 0x10, 0x1F,
+    0x10, 0x10, 0x1F, 0x10, 0x1F,
+    0x14, 0x14, 0x14, 0x1F, 0x00,
+    0x10, 0x10, 0x10, 0xF0, 0x00,
+    0x00, 0x00, 0x00, 0x1F, 0x10,
+    0x10, 0x10, 0x10, 0x1F, 0x10,
+    0x10, 0x10, 0x10, 0xF0, 0x10,
+    0x00, 0x00, 0x00, 0xFF, 0x10,
+    0x10, 0x10, 0x10, 0x10, 0x10,
+    0x10, 0x10, 0x10, 0xFF, 0x10,
+    0x00, 0x00, 0x00, 0xFF, 0x14,
+    0x00, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x00, 0x1F, 0x10, 0x17,
+    0x00, 0x00, 0xFC, 0x04, 0xF4,
+    0x14, 0x14, 0x17, 0x10, 0x17,
+    0x14, 0x14, 0xF4, 0x04, 0xF4,
+    0x00, 0x00, 0xFF, 0x00, 0xF7,
+    0x14, 0x14, 0x14, 0x14, 0x14,
+    0x14, 0x14, 0xF7, 0x00, 0xF7,
+    0x14, 0x14, 0x14, 0x17, 0x14,
+    0x10, 0x10, 0x1F, 0x10, 0x1F,
+    0x14, 0x14, 0x14, 0xF4, 0x14,
+    0x10, 0x10, 0xF0, 0x10, 0xF0,
+    0x00, 0x00, 0x1F, 0x10, 0x1F,
+    0x00, 0x00, 0x00, 0x1F, 0x14,
+    0x00, 0x00, 0x00, 0xFC, 0x14,
+    0x00, 0x00, 0xF0, 0x10, 0xF0,
+    0x10, 0x10, 0xFF, 0x10, 0xFF,
+    0x14, 0x14, 0x14, 0xFF, 0x14,
+    0x10, 0x10, 0x10, 0x1F, 0x00,
+    0x00, 0x00, 0x00, 0xF0, 0x10,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
+    0xFF, 0xFF, 0xFF, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xFF, 0xFF,
+    0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
+    0x38, 0x44, 0x44, 0x38, 0x44,
+    0x7C, 0x2A, 0x2A, 0x3E, 0x14,
+    0x7E, 0x02, 0x02, 0x06, 0x06,
+    0x02, 0x7E, 0x02, 0x7E, 0x02,
+    0x63, 0x55, 0x49, 0x41, 0x63,
+    0x38, 0x44, 0x44, 0x3C, 0x04,
+    0x40, 0x7E, 0x20, 0x1E, 0x20,
+    0x06, 0x02, 0x7E, 0x02, 0x02,
+    0x99, 0xA5, 0xE7, 0xA5, 0x99,
+    0x1C, 0x2A, 0x49, 0x2A, 0x1C,
+    0x4C, 0x72, 0x01, 0x72, 0x4C,
+    0x30, 0x4A, 0x4D, 0x4D, 0x30,
+    0x30, 0x48, 0x78, 0x48, 0x30,
+    0xBC, 0x62, 0x5A, 0x46, 0x3D,
+    0x3E, 0x49, 0x49, 0x49, 0x00,
+    0x7E, 0x01, 0x01, 0x01, 0x7E,
+    0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
+    0x44, 0x44, 0x5F, 0x44, 0x44,
+    0x40, 0x51, 0x4A, 0x44, 0x40,
+    0x40, 0x44, 0x4A, 0x51, 0x40,
+    0x00, 0x00, 0xFF, 0x01, 0x03,
+    0xE0, 0x80, 0xFF, 0x00, 0x00,
+    0x08, 0x08, 0x6B, 0x6B, 0x08,
+    0x36, 0x12, 0x36, 0x24, 0x36,
+    0x06, 0x0F, 0x09, 0x0F, 0x06,
+    0x00, 0x00, 0x18, 0x18, 0x00,
+    0x00, 0x00, 0x10, 0x10, 0x00,
+    0x30, 0x40, 0xFF, 0x01, 0x01,
+    0x00, 0x1F, 0x01, 0x01, 0x1E,
+    0x00, 0x19, 0x1D, 0x17, 0x12,
+    0x00, 0x3C, 0x3C, 0x3C, 0x3C,
+    0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/**
+ * @brief C++ API for ST7735 SPI LCD module
+ *
+ * This file defines the ST7735 C++ interface for libst7735
+ *
+ * @snippet st7735.cxx Interesting
+ */
+class ST7735 : public GFX {
+    public:
+        /**
+         * Instanciates a ST7735 object
+         *
+         * @param csLCD LCD chip select pin
+         * @param cSD SD card chip select pin
+         * @param rs data/command pin
+         * @param rst reset pin
+         */
+        ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst);
+
+        /**
+         * ST7735 object destructor
+         */
+        ~ST7735 ();
+
+        /**
+         * Return name of the component
+         */
+        std::string name()
+        {
+            return m_name;
+        }
+
+        /**
+         * Initialize the modules GPIOs
+         */
+        void initModule ();
+
+        /**
+         * Configure the chip via SPI interface
+         */
+        void configModule ();
+
+        /**
+         * Send command to SPI bus (rs must be LOW)
+         *
+         * @param value command number
+         */
+        void write (uint8_t value);
+
+        /**
+         * Send data to SPI bus (rs must be HIGH)
+         *
+         * @param value command number
+         */
+        void data (uint8_t value);
+
+        /**
+         * Execute set of commands and data
+         *
+         * @param *addr pointer to start of the commands/data section
+         */
+        void executeCMDList (const uint8_t *addr);
+
+        /**
+         * Set the window size inside the screen where the pixels data
+         * will be written.
+         *
+         * @param x0 first coordinate
+         * @param y0 first coordinate
+         * @param x1 second coordinate
+         * @param y1 second coordinate
+         */
+        void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1);
+
+        /**
+         * Send pixel collor (RGB) to the chip.
+         *
+         * @param x axis on horizontal scale
+         * @param y axis on vertical scale
+         * @param color rgb (16bit) color (R[0-4], G[5-10], B[11-15])
+         */
+        void drawPixel (int16_t x, int16_t y, uint16_t color);
+
+        /**
+         * Copy the buffer to the chip via SPI interface.
+         */
+        void refresh ();
+
+        /**
+         * LCD chip select LOW.
+         */
+        mraa_result_t lcdCSOn ();
+
+        /**
+         * LCD chip select HIGH.
+         */
+        mraa_result_t lcdCSOff ();
+
+        /**
+         * CD card chip select LOW.
+         */
+        mraa_result_t sdCSOn ();
+
+        /**
+         * CD card select HIGH.
+         */
+        mraa_result_t sdCSOff ();
+
+        /**
+         * Data select HIGH.
+         */
+        mraa_result_t rsHIGH ();
+
+        /**
+         * Data select LOW.
+         */
+        mraa_result_t rsLOW ();
+
+        uint8_t m_map[160 * 128 * 2]; /**< Screens buffer */
+    private:
+        mraa_spi_context      m_spi;
+        uint8_t              m_csLCD;
+        uint8_t              m_cSD;
+        uint8_t              m_rST;
+        uint8_t              m_rS;
+
+        mraa_gpio_context     m_csLCDPinCtx;
+        mraa_gpio_context     m_cSDPinCtx;
+        mraa_gpio_context     m_rSTPinCtx;
+        mraa_gpio_context     m_rSPinCtx;
+
+        uint8_t              m_spiBuffer[32];
+
+        std::string          m_name;
+};
+
+}

src/stepmotor/CMakeLists.txt

@@ -0,0 +1,5 @@
+set (libname "stepmotor")
+set (libdescription "upm STEPMOTOR")
+set (module_src ${libname}.cxx)
+set (module_h ${libname}.h)
+upm_module_init()

src/stepmotor/jsupm_stepmotor.i

@@ -0,0 +1,7 @@
+%module jsupm_stepmotor
+
+%{
+    #include "stepmotor.h"
+%}
+
+%include "stepmotor.h"

src/stepmotor/pyupm_stepmotor.i

@@ -0,0 +1,10 @@
+%module pyupm_stepmotor
+
+%include "stdint.i"
+
+%feature("autodoc", "3");
+
+%include "stepmotor.h"
+%{
+    #include "stepmotor.h"
+%}

src/stepmotor/stepmotor.cxx

@@ -0,0 +1,127 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * 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 <iostream>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "stepmotor.h"
+
+using namespace upm;
+
+StepMotor::StepMotor (int dirPin, int stePin) {
+    mraa_result_t error = MRAA_SUCCESS;
+    m_name = "StepMotor";
+
+    mraa_init();
+
+    m_stePin = stePin;
+    m_dirPin = dirPin;
+
+    m_pwmStepContext = mraa_pwm_init (m_stePin);
+    m_dirPinCtx = mraa_gpio_init (m_dirPin);
+    if (m_dirPinCtx == NULL) {
+        fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_dirPin);
+        exit (1);
+    }
+
+    error = mraa_gpio_dir (m_dirPinCtx, MRAA_GPIO_OUT);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+}
+
+StepMotor::~StepMotor() {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    mraa_pwm_close (m_pwmStepContext);
+
+    error = mraa_gpio_close (m_dirPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
+    }
+}
+
+void
+StepMotor::setSpeed (int speed) {
+    if (speed > MAX_PERIOD) {
+        m_speed = MAX_PERIOD;
+    }
+
+    if (speed < MIN_PERIOD) {
+        m_speed = MIN_PERIOD;
+    }
+
+    m_speed = speed;
+}
+
+mraa_result_t
+StepMotor::stepForward (int ticks) {
+    dirForward ();
+    move (ticks);
+}
+
+mraa_result_t
+StepMotor::stepBackwards (int ticks) {
+    dirBackwards ();
+    move (ticks);
+}
+
+mraa_result_t
+StepMotor::move (int ticks) {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    mraa_pwm_enable (m_pwmStepContext, 1);
+    for (int tick = 0; tick < ticks; tick++) {
+        mraa_pwm_period_us (m_pwmStepContext, m_speed);
+        mraa_pwm_pulsewidth_us (m_pwmStepContext, PULSEWIDTH);
+    }
+    mraa_pwm_enable (m_pwmStepContext, 0);
+
+    return error;
+}
+
+mraa_result_t
+StepMotor::dirForward () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_dirPinCtx, HIGH);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}
+
+mraa_result_t
+StepMotor::dirBackwards () {
+    mraa_result_t error = MRAA_SUCCESS;
+
+    error = mraa_gpio_write (m_dirPinCtx, LOW);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print (error);
+    }
+
+    return error;
+}

src/stepmotor/stepmotor.h

@@ -0,0 +1,101 @@
+/*
+ * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * Credits to Adafruit.
+ * Based on Adafruit BMP085 library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+
+#include <string>
+#include <math.h>
+#include <mraa/pwm.h>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
+
+#define MIN_PERIOD         500
+#define MAX_PERIOD         1000
+#define PULSEWIDTH         480
+
+#define HIGH               1
+#define LOW                0
+
+namespace upm {
+
+/**
+ * @brief C++ API for StepMotor Drivers
+ *
+ * This file defines the stepmotor C++ interface for libstepmotor
+ *
+ * @snippet stepmotor.cxx Interesting
+ */
+class StepMotor {
+    public:
+        /**
+         * Instanciates a StepMotor object
+         *
+         * @param dirPin direction pin
+         * @param stePin steper pulse pin
+         */
+        StepMotor (int dirPin, int stePin);
+
+        /**
+         * StepMotor object destructor.
+         */
+        ~StepMotor ();
+
+        /**
+         * Set the speed of rotation
+         *
+         * @param speed rotation speed
+         */
+        void setSpeed (int speed);
+
+        /**
+         * Rotate motor forward
+         *
+         * @param ticks number of tickes the motor will move
+         */
+        mraa_result_t stepForward (int ticks);
+
+        /**
+         * Rotate motor backward
+         *
+         * @param ticks number of tickes the motor will move
+         */
+        mraa_result_t stepBackwards (int ticks);
+
+    private:
+        std::string         m_name;
+
+        int                 m_dirPin;
+        int                 m_stePin;
+        int                 m_speed;
+
+        mraa_gpio_context    m_dirPinCtx;
+        mraa_pwm_context     m_pwmStepContext;
+
+        mraa_result_t move (int ticks);
+        mraa_result_t dirForward ();
+        mraa_result_t dirBackwards ();
+    };
+}

src/tm1637/tm1637.cxx

@@ -51,56 +51,56 @@ const uint8_t digitToSegment[] = {
 };
 
 TM1637::TM1637 (uint8_t di, uint8_t dcki) {
-    maa_result_t error = MAA_SUCCESS;
-    maa_init();
+    mraa_result_t error = MRAA_SUCCESS;
+    mraa_init();
 
     // init clock context
-    m_clkPinCtx = maa_gpio_init(dcki);
+    m_clkPinCtx = mraa_gpio_init(dcki);
     if (m_clkPinCtx == NULL) {
         fprintf(stderr, "Are you sure that pin%d you requested is valid on your platform?", dcki);
         exit(1);
     }
     // init data context
-    m_dataPinCtx = maa_gpio_init(di);
+    m_dataPinCtx = mraa_gpio_init(di);
     if (m_dataPinCtx == NULL) {
         fprintf(stderr, "Are you sure that pin%d you requested is valid on your platform?", di);
         exit(1);
     }
     
     // set direction (out)
-    error = maa_gpio_dir(m_clkPinCtx, MAA_GPIO_IN);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_dir(m_clkPinCtx, MRAA_GPIO_IN);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 
     // set direction (out)
-    error = maa_gpio_dir(m_dataPinCtx, MAA_GPIO_IN);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_dir(m_dataPinCtx, MRAA_GPIO_IN);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 
-    error = maa_gpio_write (m_dataPinCtx, LOW);
-    error = maa_gpio_write (m_clkPinCtx, LOW);
+    error = mraa_gpio_write (m_dataPinCtx, LOW);
+    error = mraa_gpio_write (m_clkPinCtx, LOW);
 }
 
 TM1637::~TM1637() {
-    maa_result_t error = MAA_SUCCESS;
-    error = maa_gpio_close (m_dataPinCtx);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    mraa_result_t error = MRAA_SUCCESS;
+    error = mraa_gpio_close (m_dataPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
-    error = maa_gpio_close (m_clkPinCtx);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+    error = mraa_gpio_close (m_clkPinCtx);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 }
 
-maa_result_t
+mraa_result_t
 TM1637::setBrightness (uint8_t level) {
     m_brightness = level;
 }
 
-maa_result_t
+mraa_result_t
 TM1637::setSegments (const uint8_t segments[], uint8_t length, uint8_t pos) {
     start();
     writeByte(TM1637_I2C_COMM1);
@@ -118,7 +118,7 @@ TM1637::setSegments (const uint8_t segments[], uint8_t length, uint8_t pos) {
     stop();
 }
 
-maa_result_t
+mraa_result_t
 TM1637::write (std::string msg) {
     char leter = '\0';
     uint8_t data[] = { 0x0, 0x0, 0x0, 0x0 };
@@ -132,60 +132,60 @@ TM1637::write (std::string msg) {
     setSegments(data);
 }
 
-maa_result_t
-TM1637::pinMode (maa_gpio_context ctx, gpio_dir_t mode) {
-    maa_result_t error = MAA_SUCCESS;
-    error = maa_gpio_dir(ctx, mode);
-    if (error != MAA_SUCCESS) {
-        maa_result_print(error);
+mraa_result_t
+TM1637::pinMode (mraa_gpio_context ctx, gpio_dir_t mode) {
+    mraa_result_t error = MRAA_SUCCESS;
+    error = mraa_gpio_dir(ctx, mode);
+    if (error != MRAA_SUCCESS) {
+        mraa_result_print(error);
     }
 }
 
-maa_result_t
+mraa_result_t
 TM1637::start() {
-    pinMode (m_dataPinCtx, MAA_GPIO_OUT);
+    pinMode (m_dataPinCtx, MRAA_GPIO_OUT);
     usleep(PULSE_LENGTH);
 }
 
-maa_result_t
+mraa_result_t
 TM1637::stop() {
-    pinMode (m_dataPinCtx, MAA_GPIO_OUT);
+    pinMode (m_dataPinCtx, MRAA_GPIO_OUT);
     usleep(PULSE_LENGTH);
-    pinMode (m_clkPinCtx, MAA_GPIO_IN);
+    pinMode (m_clkPinCtx, MRAA_GPIO_IN);
     usleep(PULSE_LENGTH);
-    pinMode (m_dataPinCtx, MAA_GPIO_IN);
+    pinMode (m_dataPinCtx, MRAA_GPIO_IN);
     usleep(PULSE_LENGTH);
 }
 
-maa_result_t
+mraa_result_t
 TM1637::writeByte(uint8_t value) {
     for (uint8_t idx = 0; idx < 8; idx++) {
-        pinMode(m_clkPinCtx, MAA_GPIO_OUT);
+        pinMode(m_clkPinCtx, MRAA_GPIO_OUT);
         usleep(PULSE_LENGTH);
         if (value & 0x01) {
-              pinMode(m_dataPinCtx, MAA_GPIO_IN);
+              pinMode(m_dataPinCtx, MRAA_GPIO_IN);
         } else {
-              pinMode(m_dataPinCtx, MAA_GPIO_OUT);
+              pinMode(m_dataPinCtx, MRAA_GPIO_OUT);
         }
         usleep(PULSE_LENGTH);
 
-        pinMode(m_clkPinCtx, MAA_GPIO_IN);
+        pinMode(m_clkPinCtx, MRAA_GPIO_IN);
         usleep(PULSE_LENGTH);
         value = value >> 1;
     }
 
-    pinMode(m_clkPinCtx, MAA_GPIO_OUT);
-    pinMode(m_dataPinCtx, MAA_GPIO_IN);
+    pinMode(m_clkPinCtx, MRAA_GPIO_OUT);
+    pinMode(m_dataPinCtx, MRAA_GPIO_IN);
     usleep(PULSE_LENGTH);
 
-    pinMode(m_clkPinCtx, MAA_GPIO_IN);
+    pinMode(m_clkPinCtx, MRAA_GPIO_IN);
     usleep(PULSE_LENGTH);
 
-    uint8_t ack = maa_gpio_read (m_dataPinCtx);
+    uint8_t ack = mraa_gpio_read (m_dataPinCtx);
     if (ack == 0) {
-        pinMode(m_dataPinCtx, MAA_GPIO_OUT);
+        pinMode(m_dataPinCtx, MRAA_GPIO_OUT);
     } usleep(PULSE_LENGTH);
 
-    pinMode(m_clkPinCtx, MAA_GPIO_OUT);
+    pinMode(m_clkPinCtx, MRAA_GPIO_OUT);
     usleep(50);
 }

src/tm1637/tm1637.h

@@ -24,8 +24,8 @@
 #pragma once
 
 #include <string>
-#include <maa/aio.h>
-#include <maa/gpio.h>
+#include <mraa/aio.h>
+#include <mraa/gpio.h>
 
 #define SEG_A               0b00000001
 #define SEG_B               0b00000010
@@ -82,7 +82,7 @@ class TM1637 {
          *
          * @param level The brightness level of leds
          */
-        maa_result_t setBrightness (uint8_t level);
+        mraa_result_t setBrightness (uint8_t level);
 
         /**
          * Set the the segment screen data and number of segments
@@ -92,14 +92,14 @@ class TM1637 {
          * @param length number of elements in segments array
          * @param pos data writing offset
          */
-        maa_result_t setSegments (const uint8_t segments[], uint8_t length = 4, uint8_t pos = 0);
+        mraa_result_t setSegments (const uint8_t segments[], uint8_t length = 4, uint8_t pos = 0);
 
         /**
          * Write message on the screen.
          *
          * @param msg The message to be written on the sreen
          */
-        maa_result_t write (std::string msg);
+        mraa_result_t write (std::string msg);
 
         /**
          * Return name of the component
@@ -110,13 +110,13 @@ class TM1637 {
         }
 
     private:
-        maa_result_t start();
-        maa_result_t stop();
-        maa_result_t writeByte (uint8_t value);
-        maa_result_t pinMode (maa_gpio_context ctx, gpio_dir_t mode);
+        mraa_result_t start();
+        mraa_result_t stop();
+        mraa_result_t writeByte (uint8_t value);
+        mraa_result_t pinMode (mraa_gpio_context ctx, gpio_dir_t mode);
 
-        maa_gpio_context m_clkPinCtx;
-        maa_gpio_context m_dataPinCtx;
+        mraa_gpio_context m_clkPinCtx;
+        mraa_gpio_context m_dataPinCtx;
 
         std::string m_name;
         uint8_t m_brightness;