mock: implement UART functionality

Signed-off-by: Alex Tereschenko <alext.mkrs@gmail.com>
Signed-off-by: Brendan Le Foll <brendan.le.foll@intel.com>

src/CMakeLists.txt

@@ -91,6 +91,7 @@ set (mraa_LIB_MOCK_SRCS_NOAUTO
   ${PROJECT_SOURCE_DIR}/src/mock/mock_board_aio.c
   ${PROJECT_SOURCE_DIR}/src/mock/mock_board_i2c.c
   ${PROJECT_SOURCE_DIR}/src/mock/mock_board_spi.c
+  ${PROJECT_SOURCE_DIR}/src/mock/mock_board_uart.c
 )
 
 if (JSONPLAT)

src/mock/mock_board.c

@@ -31,8 +31,10 @@
 #include "mock/mock_board_aio.h"
 #include "mock/mock_board_i2c.h"
 #include "mock/mock_board_spi.h"
+#include "mock/mock_board_uart.h"
 
 #define PLATFORM_NAME "MRAA mock platform"
+#define UART_DEV_PATH "dummy"
 
 mraa_board_t*
 mraa_mock_board()
@@ -69,6 +71,12 @@ mraa_mock_board()
     b->pwm_max_period = 0;
     b->pwm_min_period = 0;
 
+    b->uart_dev_count = 1;
+    b->def_uart_dev = 0;
+    b->uart_dev[0].rx = 8;
+    b->uart_dev[0].tx = 9;
+    b->uart_dev[0].device_path = UART_DEV_PATH;
+
     b->pins = (mraa_pininfo_t*) malloc(sizeof(mraa_pininfo_t) * MRAA_MOCK_PINCOUNT);
     if (b->pins == NULL) {
         goto error;
@@ -117,6 +125,16 @@ mraa_mock_board()
     b->adv_func->spi_write_word_replace = &mraa_mock_spi_write_word_replace;
     b->adv_func->spi_transfer_buf_replace = &mraa_mock_spi_transfer_buf_replace;
     b->adv_func->spi_transfer_buf_word_replace = &mraa_mock_spi_transfer_buf_word_replace;
+    b->adv_func->uart_init_raw_replace = &mraa_mock_uart_init_raw_replace;
+    b->adv_func->uart_set_baudrate_replace = &mraa_mock_uart_set_baudrate_replace;
+    b->adv_func->uart_flush_replace = &mraa_mock_uart_flush_replace;
+    b->adv_func->uart_set_flowcontrol_replace = &mraa_mock_uart_set_flowcontrol_replace;
+    b->adv_func->uart_set_mode_replace = &mraa_mock_uart_set_mode_replace;
+    b->adv_func->uart_set_non_blocking_replace = &mraa_mock_uart_set_non_blocking_replace;
+    b->adv_func->uart_set_timeout_replace = &mraa_mock_uart_set_timeout_replace;
+    b->adv_func->uart_data_available_replace = &mraa_mock_uart_data_available_replace;
+    b->adv_func->uart_write_replace = &mraa_mock_uart_write_replace;
+    b->adv_func->uart_read_replace = &mraa_mock_uart_read_replace;
 
     // Pin definitions
     int pos = 0;
@@ -169,6 +187,20 @@ mraa_mock_board()
     b->pins[pos].spi.pinmap = 0;
     pos++;
 
+    strncpy(b->pins[pos].name, "UART0RX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
+    strncpy(b->pins[pos].name, "UART0TX", 8);
+    b->pins[pos].capabilities = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 0, 0, 1 };
+    b->pins[pos].uart.pinmap = 0;
+    b->pins[pos].uart.parent_id = 0;
+    b->pins[pos].uart.mux_total = 0;
+    pos++;
+
     return b;
 
 error:

src/mock/mock_board_uart.c

@@ -0,0 +1,100 @@
+/*
+ * Author: Alex Tereschenko <alext.mkrs@gmail.com>
+ * Copyright (c) 2016 Alex Tereschenko.
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "mock/mock_board_uart.h"
+
+mraa_result_t
+mraa_mock_uart_set_baudrate_replace(mraa_uart_context dev, unsigned int baud)
+{
+    // Limits are taken from uart.c::uint2speed(), they don't matter much anyway
+    if ((baud < 0) || (baud > 4000000)) {
+        syslog(LOG_ERR, "uart%i: set_baudrate: invalid baudrate: %i", dev->index, baud);
+        return MRAA_ERROR_INVALID_PARAMETER;
+    }
+
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_uart_init_raw_replace(mraa_uart_context dev, const char* path)
+{
+    // The only thing we have to do from the original uart_init_raw()
+    return mraa_uart_set_baudrate(dev, 9600);
+}
+
+mraa_result_t
+mraa_mock_uart_flush_replace(mraa_uart_context dev)
+{
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_uart_set_flowcontrol_replace(mraa_uart_context dev, mraa_boolean_t xonxoff, mraa_boolean_t rtscts)
+{
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_uart_set_mode_replace(mraa_uart_context dev, int bytesize, mraa_uart_parity_t parity, int stopbits)
+{
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_uart_set_non_blocking_replace(mraa_uart_context dev, mraa_boolean_t nonblock)
+{
+    return MRAA_SUCCESS;
+}
+
+mraa_result_t
+mraa_mock_uart_set_timeout_replace(mraa_uart_context dev, int read, int write, int interchar)
+{
+    return MRAA_SUCCESS;
+}
+
+mraa_boolean_t
+mraa_mock_uart_data_available_replace(mraa_uart_context dev, unsigned int millis)
+{
+    // Our mock implementation will always have "incoming" data
+    return 1;
+}
+
+int
+mraa_mock_uart_write_replace(mraa_uart_context dev, const char* buf, size_t len)
+{
+    // Our mock implementation always succeeds when sending data
+    return len;
+}
+
+int
+mraa_mock_uart_read_replace(mraa_uart_context dev, char* buf, size_t len)
+{
+    // We'll return MOCK_UART_DATA_BYTE, len times
+    memset(buf, MOCK_UART_DATA_BYTE, len);
+    return len;
+}

src/uart/uart.c

@@ -261,7 +261,7 @@ mraa_uart_init_raw(const char* path)
 init_raw_cleanup:
     if (status != MRAA_SUCCESS) {
         if (dev != NULL) {
-            if (dev->fd != -1) {
+            if (dev->fd >= 0) {
                 close(dev->fd);
             }
             free(dev);