1 /* 2 * Author: Brendan Le Foll <brendan.le.foll@intel.com> 3 * Contributions: Jon Trulson <jtrulson@ics.com> 4 * Contributions: Thomas Ingleby <thomas.c.ingleby@intel.com> 5 * Copyright (c) 2014 - 2015 Intel Corporation. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining 8 * a copy of this software and associated documentation files (the 9 * "Software"), to deal in the Software without restriction, including 10 * without limitation the rights to use, copy, modify, merge, publish, 11 * distribute, sublicense, and/or sell copies of the Software, and to 12 * permit persons to whom the Software is furnished to do so, subject to 13 * the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be 16 * included in all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 22 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 24 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 */ 26 27 #pragma once 28 29 #include "uart.h" 30 #include "types.hpp" 31 #include <stdlib.h> 32 #include <stdexcept> 33 #include <cstring> 34 35 namespace mraa 36 { 37 38 /** 39 * @brief API to UART (enabling only) 40 * 41 * This file defines the UART interface for libmraa 42 * 43 * @snippet Uart-example.cpp Interesting 44 */ 45 class Uart 46 { 47 public: 48 /** 49 * Uart Constructor, takes a pin number which will map directly to the 50 * linux uart number, this 'enables' the uart, nothing more 51 * 52 * @param uart the index of the uart set to use 53 */ Uart(int uart)54 Uart(int uart) 55 { 56 m_uart = mraa_uart_init(uart); 57 58 if (m_uart == NULL) { 59 throw std::invalid_argument("Error initialising UART"); 60 } 61 } 62 63 /** 64 * Uart Constructor, takes a string to the path of the serial 65 * interface that is needed. 66 * 67 * @param uart the index of the uart set to use 68 */ Uart(std::string path)69 Uart(std::string path) 70 { 71 m_uart = mraa_uart_init_raw(path.c_str()); 72 73 if (m_uart == NULL) { 74 throw std::invalid_argument("Error initialising UART"); 75 } 76 } 77 78 /** 79 * Uart destructor 80 */ ~Uart()81 ~Uart() 82 { 83 mraa_uart_stop(m_uart); 84 } 85 86 /** 87 * Get string with tty device path within Linux 88 * For example. Could point to "/dev/ttyS0" 89 * 90 * @return char pointer of device path 91 */ 92 std::string getDevicePath()93 getDevicePath() 94 { 95 std::string ret_val(mraa_uart_get_dev_path(m_uart)); 96 return ret_val; 97 } 98 99 /** 100 * Read bytes from the device into char* buffer 101 * 102 * @param data buffer pointer 103 * @param length maximum size of buffer 104 * @return numbers of bytes read 105 */ 106 int read(char * data,int length)107 read(char* data, int length) 108 { 109 return mraa_uart_read(m_uart, data, (size_t) length); 110 } 111 112 /** 113 * Write bytes in String object to a device 114 * 115 * @param data buffer pointer 116 * @param length maximum size of buffer 117 * @return the number of bytes written, or -1 if an error occurred 118 */ 119 int write(const char * data,int length)120 write(const char* data, int length) 121 { 122 return mraa_uart_write(m_uart, data, (size_t) length); 123 } 124 125 /** 126 * Read bytes from the device into a String object 127 * 128 * @param length to read 129 * @return string of data 130 */ 131 std::string readStr(int length)132 readStr(int length) 133 { 134 char* data = (char*) malloc(sizeof(char) * length); 135 int v = mraa_uart_read(m_uart, data, (size_t) length); 136 std::string ret(data, v); 137 free(data); 138 return ret; 139 } 140 141 /** 142 * Write bytes in String object to a device 143 * 144 * @param string to write 145 * @return the number of bytes written, or -1 if an error occurred 146 */ 147 int writeStr(std::string data)148 writeStr(std::string data) 149 { 150 // this is data.length() not +1 because we want to avoid the '\0' char 151 return mraa_uart_write(m_uart, data.c_str(), (data.length())); 152 } 153 154 /** 155 * Check to see if data is available on the device for reading 156 * 157 * @param millis number of milliseconds to wait, or 0 to return immediately 158 * @return true if there is data available to read, false otherwise 159 */ 160 bool dataAvailable(unsigned int millis=0)161 dataAvailable(unsigned int millis = 0) 162 { 163 if (mraa_uart_data_available(m_uart, millis)) 164 return true; 165 else 166 return false; 167 } 168 169 /** 170 * Flush the outbound data. 171 * Blocks until complete. 172 * 173 * @return Result of operation 174 */ 175 Result flush()176 flush() 177 { 178 return (Result) mraa_uart_flush(m_uart); 179 } 180 181 /** 182 * Set the baudrate. 183 * Takes an int and will attempt to decide what baudrate is 184 * to be used on the UART hardware. 185 * 186 * @param baud unsigned int of baudrate i.e. 9600 187 * @return Result of operation 188 */ 189 Result setBaudRate(unsigned int baud)190 setBaudRate(unsigned int baud) 191 { 192 return (Result) mraa_uart_set_baudrate(m_uart, baud); 193 } 194 195 /** 196 * Set the transfer mode 197 * For example setting the mode to 8N1 would be 198 * "dev.setMode(8,UART_PARITY_NONE , 1)" 199 * 200 * @param bytesize data bits 201 * @param parity Parity bit setting 202 * @param stopbits stop bits 203 * @return Result of operation 204 */ 205 Result setMode(int bytesize,UartParity parity,int stopbits)206 setMode(int bytesize, UartParity parity, int stopbits) 207 { 208 return (Result) mraa_uart_set_mode(m_uart, bytesize, (mraa_uart_parity_t) parity, stopbits); 209 } 210 211 /** 212 * Set the flowcontrol 213 * 214 * @param xonxoff XON/XOFF Software flow control. 215 * @param rtscts RTS/CTS out of band hardware flow control 216 * @return Result of operation 217 */ 218 Result setFlowcontrol(bool xonxoff,bool rtscts)219 setFlowcontrol(bool xonxoff, bool rtscts) 220 { 221 return (Result) mraa_uart_set_flowcontrol(m_uart, xonxoff, rtscts); 222 } 223 224 /** 225 * Set the timeout for read and write operations 226 * <= 0 will disable that timeout 227 * 228 * @param read read timeout 229 * @param write write timeout 230 * @param interchar inbetween char timeout 231 * @return Result of operation 232 */ 233 Result setTimeout(int read,int write,int interchar)234 setTimeout(int read, int write, int interchar) 235 { 236 return (Result) mraa_uart_set_timeout(m_uart, read, write, interchar); 237 } 238 239 private: 240 mraa_uart_context m_uart; 241 }; 242 } 243