common.hpp

Go to the documentation of this file.

/*
 * Author: Thomas Ingleby <thomas.c.ingleby@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 "common.h"
#include "types.hpp"
#include <string>
#include <sstream>
#include <stdexcept>

namespace mraa
{

inline Result
init()
{
    return (Result) mraa_init();
}

inline std::string
getVersion()
{
    std::string ret = mraa_get_version();
    return ret;
}

inline int
setPriority(const int priority)
{
    return mraa_set_priority(priority);
}

inline Platform
getPlatformType()
{
    return (Platform) mraa_get_platform_type();
}

inline void
printError(Result result)
{
    mraa_result_print((mraa_result_t) result);
}

inline bool
pinModeTest(int pin, Pinmodes mode)
{
    return (bool) mraa_pin_mode_test(pin, (mraa_pinmodes_t) mode);
}

inline unsigned int
adcRawBits()
{
    return mraa_adc_raw_bits();
}

inline unsigned int
adcSupportedBits()
{
    return mraa_adc_supported_bits();
}

inline std::string
getPlatformName()
{
    std::string ret_val;
    const char * pn = mraa_get_platform_name();
    if (pn) ret_val = pn;
    return ret_val;
}

inline std::string
getPlatformVersion(int platform_offset=MRAA_MAIN_PLATFORM_OFFSET)
{
    std::string ret_val;
    const char* pv = mraa_get_platform_version(platform_offset);
    if (pv) ret_val = pv;
    return ret_val;
}

inline unsigned int
getPinCount()
{
    return mraa_get_pin_count();
}

inline int
getUartCount()
{
    return mraa_get_uart_count();
}

inline int
getI2cBusCount()
{
    return mraa_get_i2c_bus_count();
}

inline int
getI2cBusId(int i2c_bus)
{
    return mraa_get_i2c_bus_id(i2c_bus);
}

inline std::string
getPinName(int pin)
{
    std::string ret_val;
    const char* pn = mraa_get_pin_name(pin);
    if (pn) ret_val = pn;
    return ret_val;
}

inline int
getGpioLookup(std::string pin_name)
{
    int index = mraa_gpio_lookup(pin_name.c_str());

    if (index < 0){
        std::ostringstream oss;
        oss << "Gpio name " << pin_name << " is not valid";
        throw std::invalid_argument(oss.str());
    }

    return index;
}

inline int
getI2cLookup(std::string i2c_name)
{
    int index = mraa_i2c_lookup(i2c_name.c_str());

    if (index < 0){
        std::ostringstream oss;
        oss << "i2c name " << i2c_name << " is not valid";
        throw std::invalid_argument(oss.str());
    }

    return index;
}

inline int
getSpiLookup(std::string spi_name)
{
    int index = mraa_spi_lookup(spi_name.c_str());

    if (index < 0){
        std::ostringstream oss;
        oss << "Spi name " << spi_name << " is not valid";
        throw std::invalid_argument(oss.str());
    }

    return index;
}

inline int
getPwmLookup(std::string pwm_name)
{
    int index = mraa_pwm_lookup(pwm_name.c_str());

    if (index < 0){
        std::ostringstream oss;
        oss << "PWM name " << pwm_name << " is not valid";
        throw std::invalid_argument(oss.str());
    }

    return index;
}

inline int
getUartLookup(std::string uart_name)
{
    int index = mraa_uart_lookup(uart_name.c_str());

    if (index < 0) {
        std::ostringstream oss;
        oss << "UART name " << uart_name << " is not valid";
        throw std::invalid_argument(oss.str());
    }

    return index;
}

inline Result
setLogLevel(int level)
{
    return (Result) mraa_set_log_level(level);
}

inline bool
hasSubPlatform()
{
    return static_cast<bool>(mraa_has_sub_platform());
}

inline bool
isSubPlatformId(int pin_or_bus_id)
{
    return static_cast<bool>(mraa_is_sub_platform_id(pin_or_bus_id));
}

inline int
getSubPlatformId(int pin_or_bus_index)
{
    return mraa_get_sub_platform_id(pin_or_bus_index);
}

inline int
getSubPlatformIndex(int pin_or_bus_id)
{
    return mraa_get_sub_platform_index(pin_or_bus_id);
}

inline int
getDefaultI2cBus(int platform_offset=MRAA_MAIN_PLATFORM_OFFSET)
{
    return mraa_get_default_i2c_bus(platform_offset);
}

inline Result
addSubplatform(Platform subplatformtype, std::string dev)
{
    return (Result) mraa_add_subplatform((mraa_platform_t) subplatformtype, dev.c_str());
}

inline Result
removeSubplatform(Platform subplatformtype)
{
    return (Result) mraa_remove_subplatform((mraa_platform_t) subplatformtype);
}

template <class T>
inline T*
initIo(std::string desc)
{
    return new T(mraa_init_io(desc.c_str()));
}

inline Result
initJsonPlatform(std::string path)
{
    return (Result) mraa_init_json_platform(path.c_str());
}

}