/*
* Author: Brendan Le Foll <brendan.le.foll@intel.com>
* Contributions: Jon Trulson <jtrulson@ics.com>
* Contributions: Thomas Ingleby <thomas.c.ingleby@intel.com>
* Copyright (c) 2014 - 2015 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 "uart.h"
#include "types.hpp"
#include <stdlib.h>
#include <stdexcept>
#include <cstring>
namespace mraa
{
/**
* @brief API to UART (enabling only)
*
* This file defines the UART interface for libmraa
*
* @snippet Uart-example.cpp Interesting
*/
class Uart
{
public:
/**
* Uart Constructor, takes a pin number which will map directly to the
* linux uart number, this 'enables' the uart, nothing more
*
* @param uart the index of the uart set to use
*/
Uart(int uart)
{
m_uart = mraa_uart_init(uart);
if (m_uart == NULL) {
throw std::invalid_argument("Error initialising UART");
}
}
/**
* Uart Constructor, takes a string to the path of the serial
* interface that is needed.
*
* @param uart the index of the uart set to use
*/
Uart(std::string path)
{
m_uart = mraa_uart_init_raw(path.c_str());
if (m_uart == NULL) {
throw std::invalid_argument("Error initialising UART");
}
}
/**
* Uart destructor
*/
~Uart()
{
mraa_uart_stop(m_uart);
}
/**
* Get string with tty device path within Linux
* For example. Could point to "/dev/ttyS0"
*
* @return char pointer of device path
*/
std::string
getDevicePath()
{
std::string ret_val(mraa_uart_get_dev_path(m_uart));
return ret_val;
}
/**
* Read bytes from the device into char* buffer
*
* @param data buffer pointer
* @param length maximum size of buffer
* @return numbers of bytes read
*/
int
read(char* data, int length)
{
return mraa_uart_read(m_uart, data, (size_t) length);
}
/**
* Write bytes in String object to a device
*
* @param data buffer pointer
* @param length maximum size of buffer
* @return the number of bytes written, or -1 if an error occurred
*/
int
write(const char* data, int length)
{
return mraa_uart_write(m_uart, data, (size_t) length);
}
/**
* Read bytes from the device into a String object
*
* @param length to read
* @return string of data
*/
std::string
readStr(int length)
{
char* data = (char*) malloc(sizeof(char) * length);
int v = mraa_uart_read(m_uart, data, (size_t) length);
std::string ret(data, v);
free(data);
return ret;
}
/**
* Write bytes in String object to a device
*
* @param string to write
* @return the number of bytes written, or -1 if an error occurred
*/
int
writeStr(std::string data)
{
// this is data.length() not +1 because we want to avoid the '\0' char
return mraa_uart_write(m_uart, data.c_str(), (data.length()));
}
/**
* Check to see if data is available on the device for reading
*
* @param millis number of milliseconds to wait, or 0 to return immediately
* @return true if there is data available to read, false otherwise
*/
bool
dataAvailable(unsigned int millis = 0)
{
if (mraa_uart_data_available(m_uart, millis))
return true;
else
return false;
}
/**
* Flush the outbound data.
* Blocks until complete.
*
* @return Result of operation
*/
Result
flush()
{
return (Result) mraa_uart_flush(m_uart);
}
/**
* Set the baudrate.
* Takes an int and will attempt to decide what baudrate is
* to be used on the UART hardware.
*
* @param baud unsigned int of baudrate i.e. 9600
* @return Result of operation
*/
Result
setBaudRate(unsigned int baud)
{
return (Result) mraa_uart_set_baudrate(m_uart, baud);
}
/**
* Set the transfer mode
* For example setting the mode to 8N1 would be
* "dev.setMode(8,UART_PARITY_NONE , 1)"
*
* @param bytesize data bits
* @param parity Parity bit setting
* @param stopbits stop bits
* @return Result of operation
*/
Result
setMode(int bytesize, UartParity parity, int stopbits)
{
return (Result) mraa_uart_set_mode(m_uart, bytesize, (mraa_uart_parity_t) parity, stopbits);
}
/**
* Set the flowcontrol
*
* @param xonxoff XON/XOFF Software flow control.
* @param rtscts RTS/CTS out of band hardware flow control
* @return Result of operation
*/
Result
setFlowcontrol(bool xonxoff, bool rtscts)
{
return (Result) mraa_uart_set_flowcontrol(m_uart, xonxoff, rtscts);
}
/**
* Set the timeout for read and write operations
* <= 0 will disable that timeout
*
* @param read read timeout
* @param write write timeout
* @param interchar inbetween char timeout
* @return Result of operation
*/
Result
setTimeout(int read, int write, int interchar)
{
return (Result) mraa_uart_set_timeout(m_uart, read, write, interchar);
}
private:
mraa_uart_context m_uart;
};
}