diff --git a/api/mraa.h b/api/mraa.h index b3b0d596a..70fde77ac 100644 --- a/api/mraa.h +++ b/api/mraa.h @@ -33,6 +33,7 @@ extern "C" { #include "mraa/spi.h" #include "mraa/i2c.h" #include "mraa/uart.h" +#include "mraa/uart_ow.h" #ifdef __cplusplus } diff --git a/api/mraa/types.h b/api/mraa/types.h index af0b31bd6..6d954ceca 100644 --- a/api/mraa/types.h +++ b/api/mraa/types.h @@ -207,6 +207,9 @@ typedef enum { MRAA_ERROR_INVALID_PLATFORM = 10, /**< Platform not recognised */ MRAA_ERROR_PLATFORM_NOT_INITIALISED = 11, /**< Board information not initialised */ MRAA_ERROR_PLATFORM_ALREADY_INITIALISED = 0, /**< Board is already initialised, same as MRAA_SUCESS */ + MRAA_ERROR_UART_OW_SHORTED = 12, /**< UART OW Short Circuit Detected*/ + MRAA_ERROR_UART_OW_NO_DEVICES = 13, /**< UART OW No devices detected */ + MRAA_ERROR_UART_OW_DATA_ERROR = 14, /**< UART OW Data/Bus error detected */ MRAA_ERROR_UNSPECIFIED = 99 /**< Unknown Error */ } mraa_result_t; diff --git a/api/mraa/types.hpp b/api/mraa/types.hpp index 75bff1127..19feb11d4 100644 --- a/api/mraa/types.hpp +++ b/api/mraa/types.hpp @@ -205,6 +205,9 @@ typedef enum { ERROR_INVALID_PLATFORM = 10, /**< Platform not recognised */ ERROR_PLATFORM_NOT_INITIALISED = 11, /**< Board information not initialised */ ERROR_PLATFORM_ALREADY_INITIALISED = 0, /**< Board is already initialised, same as SUCCESS */ + ERROR_UART_OW_SHORTED = 12, /**< UART OW Short Circuit Detected*/ + ERROR_UART_OW_NO_DEVICES = 13, /**< UART OW No devices detected */ + ERROR_UART_OW_DATA_ERROR = 14, /**< UART OW Data/Bus error detected */ ERROR_UNSPECIFIED = 99 /**< Unknown Error */ } Result; diff --git a/api/mraa/uart_ow.h b/api/mraa/uart_ow.h new file mode 100644 index 000000000..f54690af9 --- /dev/null +++ b/api/mraa/uart_ow.h @@ -0,0 +1,189 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2016 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 + +/** + * @file + * @brief UART OW module + * + * This module allows one to use MRAA's UART support in order to + * interact with Dallas 1-wire compliant devices on a 1-wire bus. It + * makes use of the UART for timing purposes. The principle of + * operation is described here: + * https://www.maximintegrated.com/en/app-notes/index.mvp/id/214 + * + * It is important the you use a UART with CMOS/TTL level voltages + * (3.3v/5v) RX and TX lines. DO NOT use standard RS232 level + * voltages, or you are going to have a bad day. + * + * In addition, a diode should be placed across the RX and + * TX lines like so: + * + * -| + * U| + * A| TX---|<--+ + * R| | + * T| RX-------o--------o 1-wire data bus + * -| + * + * The diode on TX is a 1N4148 (cheap and common), with the cathode + * connected to TX, and the anode connected to RX and the rest of the + * 1-wire data line. + * + * @snippet uart_ow.c Interesting + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include "common.h" + +/* for now, we simply use the normal MRAA UART context */ +typedef struct _uart* mraa_uart_ow_context; + +/* 8 bytes (64 bits) for a device rom code */ +static const int MRAA_UART_OW_ROMCODE_SIZE = 8; + +/** + * UART One Wire ROM related Command bytes + */ +typedef enum { + MRAA_UART_OW_CMD_READ_ROM = 0x33, /**< read rom, when only one device on bus */ + MRAA_UART_OW_CMD_MATCH_ROM = 0x55, /**< match a specific rom code */ + MRAA_UART_OW_CMD_SKIP_ROM = 0xcc, /**< skip match/search rom */ + MRAA_UART_OW_CMD_SEARCH_ROM_ALARM = 0xec, /**< search all roms in alarm state */ + MRAA_UART_OW_CMD_SEARCH_ROM = 0xf0 /**< search all rom codes */ +} mraa_uart_ow_rom_cmd_t; + +/** + * Initialise uart_ow_context, uses UART board mapping + * + * @param uart the index of the uart set to use + * @return uart_ow context or NULL + */ +mraa_uart_ow_context mraa_uart_ow_init(int uart); + +/** + * Initialise a raw uart_ow_context. No board setup. + * + * @param path for example "/dev/ttyS0" + * @return uart_ow context or NULL + */ +mraa_uart_ow_context mraa_uart_ow_init_raw(const char* path); + +/** + * Get char pointer with tty device path within Linux + * For example. Could point to "/dev/ttyS0" + * + * @param dev uart_ow context + * @return char pointer of device path + */ +const char* mraa_uart_ow_get_dev_path(mraa_uart_ow_context dev); + +/** + * Destroy a mraa_uart_ow_context + * + * @param dev uart_ow context + * @return mraa_result_t + */ +mraa_result_t mraa_uart_ow_stop(mraa_uart_ow_context dev); + +/** + * Read a byte from the 1-wire bus + * + * @param dev uart_ow context + * @return the byte read + */ +uint8_t mraa_uart_ow_read_byte(mraa_uart_ow_context dev); + +/** + * Write a byte to a 1-wire bus + * + * @param dev uart_ow context + * @param byte the byte to write to the bus + * @return the byte read back during the time slot + */ +uint8_t mraa_uart_ow_write_byte(mraa_uart_ow_context dev, uint8_t byte); + +/** + * Write a bit to a 1-wire bus and read a bit corresponding to the + * time slot back. This is possible due to the way we wired the TX + * and RX together with a diode, forming a loopback. + * + * @param dev uart_ow context + * @param bit the bit to write to the bus + * @return the bit read back during the time slot + */ +uint8_t mraa_uart_ow_bit(mraa_uart_ow_context dev, uint8_t bit); + +/** + * Send a reset pulse to the 1-wire bus and test for device presence + * + * @param dev uart_ow context + * @return one of the mraa_result_t values + */ +mraa_result_t mraa_uart_ow_reset(mraa_uart_ow_context dev); + +/** + * Begin a rom code search of the 1-wire bus. This function + * implements the 1-wire search algorithm. See the uart_ow.c example + * for an idea on how to use this function to identify all devices + * present on the bus. + * + * @param dev uart_ow context + * @param start true to start a new search from scratch, false to + * continue an existing search + * @param id the 8-byte rom code id of the current matched device when + * a device is found + * @return one of the mraa_result_t values + */ +mraa_result_t mraa_uart_ow_rom_search(mraa_uart_ow_context dev, mraa_boolean_t start, uint8_t* id); + +/** + * Send a command byte to a device on the 1-wire bus + * + * @param dev uart_ow context + * @param command the command byte to send + * @param id the rom code id of the device to receive the command, + * NULL for all devices on the bus + * @return one of the mraa_result_t values + */ +mraa_result_t mraa_uart_ow_command(mraa_uart_ow_context dev, uint8_t command, uint8_t* id); + +/** + * Perform a Dallas 1-wire compliant CRC8 computation on a buffer + * + * @param buffer the buffer containing the data + * @param length the length of the buffer + * @return the computed CRC + */ +uint8_t mraa_uart_ow_crc8(uint8_t* buffer, uint16_t length); + +#ifdef __cplusplus +} +#endif diff --git a/api/mraa/uart_ow.hpp b/api/mraa/uart_ow.hpp new file mode 100644 index 000000000..6c3c1d424 --- /dev/null +++ b/api/mraa/uart_ow.hpp @@ -0,0 +1,260 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2016 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_ow.h" +#include "types.hpp" +#include +#include + +namespace mraa +{ + +/** + * @brief API for UART One Wire + * + * This file defines the UartOW (UART to Dallas 1-wire) interface for libmraa + * + * @snippet UartOW.cpp Interesting + */ +class UartOW +{ + public: + /** + * UartOW 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 to use + */ + UartOW(int uart) + { + m_uart = mraa_uart_ow_init(uart); + + if (m_uart == NULL) { + throw std::invalid_argument("Error initialising UART_OW"); + } + } + + /** + * UartOW Constructor, takes a string to the path of the serial + * interface that is needed. + * + * @param path the file path for the UART to use + */ + UartOW(std::string path) + { + m_uart = mraa_uart_ow_init_raw(path.c_str()); + + if (m_uart == NULL) { + throw std::invalid_argument("Error initialising UART"); + } + } + + /** + * Uart destructor + */ + ~UartOW() + { + mraa_uart_ow_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_ow_get_dev_path(m_uart)); + return ret_val; + } + + /** + * Read a byte from the 1-wire bus + * + * @return the byte read + */ + uint8_t + readByte() + { + return mraa_uart_ow_read_byte(m_uart); + } + + /** + * Write a byte to a 1-wire bus + * + * @param byte the byte to write to the bus + * @return the byte read back during the time slot + */ + uint8_t + writeByte(uint8_t byte) + { + return mraa_uart_ow_write_byte(m_uart, byte); + } + + /** + * Write a bit to a 1-wire bus and read a bit corresponding to the + * time slot back. This is possible due to the way we wired the TX + * and RX together with a diode, forming a loopback. + * + * @param bit the bit to write to the bus + * @return the bit read back during the time slot + */ + bool + writeBit(bool bit) + { + uint8_t rv = mraa_uart_ow_bit(m_uart, (bit) ? 1 : 0); + return ((rv) ? true : false); + } + + /** + * Send a reset pulse to the 1-wire bus and test for device presence + * + * @return one of the mraa::Result values + */ + mraa::Result + reset() + { + return (mraa::Result) mraa_uart_ow_reset(m_uart); + } + + /** + * Begin a rom code search of the 1-wire bus. This function + * implements the 1-wire search algorithm. See the uart_ow.c example + * for an idea on how to use this function to identify all devices + * present on the bus. + * + * @param start true to start a search from scratch, false to + * continue a previously started search + * @param id the 8-byte rom code id of the current matched device when a + * device is found + * @return one of the mraa::Result values + */ + mraa::Result + search(bool start, uint8_t* id) + { + return (mraa::Result) mraa_uart_ow_rom_search(m_uart, (start) ? 1 : 0, id); + } + + /** + * Begin a rom code search of the 1-wire bus. This function + * implements the 1-wire search algorithm. See the UartOW.cpp + * example for an idea on how to use this function to identify all + * devices present on the bus. + * + * @param start true to start a search from scratch, false to + * continue a previously started search + * @return an empty string if no [more] devices are found, or a + * string containing the 8-byte romcode of a detected device. + */ + std::string + search(bool start) + { + uint8_t id[MRAA_UART_OW_ROMCODE_SIZE]; + mraa_result_t rv; + + rv = mraa_uart_ow_rom_search(m_uart, (start) ? 1 : 0, id); + + if (rv == MRAA_SUCCESS) { + // we found one + std::string idStr((char*) id, MRAA_UART_OW_ROMCODE_SIZE); + return idStr; + } else { + // failure, or end of search + return ""; + } + } + + /** + * Send a command byte to a device on the 1-wire bus + * + * @param command the command byte to send + * @param id the rom code id of the device to receive the command, + * NULL for all devices on the bus + * @return one of the mraa::Result values + */ + mraa::Result + command(uint8_t command, uint8_t* id) + { + return (mraa::Result) mraa_uart_ow_command(m_uart, command, id); + } + + /** + * Send a command byte to a device on the 1-wire bus, supplying + * the id as a std::string + * + * @param command the command byte to send + * @param id std::string representing the code id of the device to + * receive the command, or an empty string for all devices on the + * bus. This string should be 8 bytes in size. + * @return one of the mraa::Result values + */ + mraa::Result + command(uint8_t command, std::string id) + { + if (id.empty() == 0) + return (mraa::Result) mraa_uart_ow_command(m_uart, command, NULL); + else { + if (id.size() != 8) { + // Only 8 byte romcodes are legal. + throw std::invalid_argument(std::string(__FUNCTION__) + + ": id must be 8 bytes only"); + } + return (mraa::Result) mraa_uart_ow_command(m_uart, command, (uint8_t*) id.c_str()); + } + } + + /** + * Perform a Dallas 1-wire compliant CRC8 computation on a buffer + * + * @param buffer the buffer containing the data + * @param length the length of the buffer + * @return the computed CRC + */ + uint8_t + crc8(uint8_t* buffer, uint16_t length) + { + return mraa_uart_ow_crc8(buffer, length); + } + + /** + * Perform a Dallas 1-wire compliant CRC8 computation on a + * std::string based buffer + * + * @param buffer std::string buffer containing the data + * @return the computed CRC + */ + uint8_t + crc8(std::string buffer) + { + return mraa_uart_ow_crc8((uint8_t*) buffer.c_str(), buffer.size()); + } + + private: + mraa_uart_ow_context m_uart; +}; +} diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index e59324312..297d96537 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -9,6 +9,7 @@ add_executable (spi_mcp4261 spi_mcp4261.c) add_executable (mmap-io2 mmap-io2.c) add_executable (blink_onboard blink_onboard.c) add_executable (uart uart.c) +add_executable (uart_ow uart_ow.c) add_executable (mraa-gpio mraa-gpio.c) add_executable (mraa-i2c mraa-i2c.c) add_executable (spi_max7219 spi_max7219.c) @@ -30,6 +31,7 @@ target_link_libraries (spi_mcp4261 mraa) target_link_libraries (mmap-io2 mraa) target_link_libraries (blink_onboard mraa) target_link_libraries (uart mraa) +target_link_libraries (uart_ow mraa) target_link_libraries (mraa-gpio mraa) target_link_libraries (mraa-i2c mraa) target_link_libraries (spi_max7219 mraa) diff --git a/examples/c++/CMakeLists.txt b/examples/c++/CMakeLists.txt index d688d4829..e9faca847 100644 --- a/examples/c++/CMakeLists.txt +++ b/examples/c++/CMakeLists.txt @@ -8,6 +8,7 @@ add_executable (Spi-pot Spi-pot.cpp) add_executable (Uart Uart-example.cpp) add_executable (Isr-pin6 Isr-pin6.cpp) add_executable (Iio-dummy Iio-dummy.cpp) +add_executable (UartOW UartOW.cpp) include_directories(${PROJECT_SOURCE_DIR}/api) @@ -19,3 +20,4 @@ target_link_libraries (Spi-pot mraa stdc++) target_link_libraries (Uart mraa stdc++) target_link_libraries (Isr-pin6 mraa stdc++) target_link_libraries (Iio-dummy mraa stdc++) +target_link_libraries (UartOW mraa stdc++) diff --git a/examples/c++/UartOW.cpp b/examples/c++/UartOW.cpp new file mode 100644 index 000000000..bccc7a2c3 --- /dev/null +++ b/examples/c++/UartOW.cpp @@ -0,0 +1,82 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2016 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 "stdio.h" +#include "iostream" +//! [Interesting] +#include "uart_ow.hpp" + +using namespace std; + +int +main(int argc, char** argv) +{ + mraa::UartOW* uart = new mraa::UartOW(0); + + // Reset the ow bus and see if anything is present + mraa::Result rv; + + if ((rv = uart->reset()) == mraa::SUCCESS) { + cout << "Reset succeeded, device(s) detected!" << endl; + } else { + cout << "Reset failed, returned " << int(rv) << ". No devices on bus?" << endl; + return 1; + } + + cout << "Looking for devices..." << endl; + ; + + uint8_t count = 0; + // start the search from scratch + string id = uart->search(true); + + if (id.empty()) { + cout << "No devices detected." << endl; + return 1; + } + + while (!id.empty()) { + // hack so we don't need to cast each element of the romcode + // for printf purposes + uint8_t* ptr = (uint8_t*) id.c_str(); + + // The first byte (0) is the device type (family) code. + // The last byte (7) is the rom code CRC value. The + // intervening bytes are the unique 48 bit device ID. + + printf("Device %02d Type 0x%02x ID %02x%02x%02x%02x%02x%02x CRC 0x%02x\n", count, ptr[0], + ptr[6], ptr[5], ptr[4], ptr[3], ptr[2], ptr[1], ptr[7]); + count++; + + // continue the search with start argument set to false + id = uart->search(false); + } + + cout << "Exiting..." << endl; + + delete uart; + + return 0; +} +//! [Interesting] diff --git a/examples/uart_ow.c b/examples/uart_ow.c new file mode 100644 index 000000000..4e15ceb42 --- /dev/null +++ b/examples/uart_ow.c @@ -0,0 +1,93 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2016 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 "stdio.h" +//! [Interesting] +#include "mraa.h" + +int +main(int argc, char** argv) +{ + mraa_uart_ow_context uart; + uart = mraa_uart_ow_init(0); + + if (!uart) { + printf("mraa_uart_ow_init() failed\n"); + return 1; + } + + // Reset the ow bus and see if anything is present + mraa_result_t rv; + + if ((rv = mraa_uart_ow_reset(uart)) == MRAA_SUCCESS) { + printf("Reset succeeded, device(s) detected!\n"); + } else { + printf("Reset failed, returned %d. No devices on bus?\n", rv); + return 1; + } + + printf("Looking for devices...\n"); + uint8_t id[MRAA_UART_OW_ROMCODE_SIZE]; + + /* we are essentially doing a binary tree search through the 64 + * bit address space. id is modified during this search, and will + * be set to the valid rom code for each device found. + */ + + uint8_t count = 0; + + // start the search from scratch + uint8_t result = mraa_uart_ow_rom_search(uart, 1, id); + + if (result == MRAA_ERROR_UART_OW_NO_DEVICES) { + printf("No devices detected.\n"); + return 1; + } + + if (result == MRAA_ERROR_UART_OW_DATA_ERROR) { + printf("Bus/Data error.\n"); + return 1; + } + + while (result == MRAA_SUCCESS) { + /* The first byte (id[0]]) is the device type (family) code. + * The last byte (id[7]) is the rom code CRC value. The + * intervening bytes (id[1]-id[6]) are the unique 48 bit + * device ID. + */ + printf("Device %02d Type 0x%02x ID %02x%02x%02x%02x%02x%02x CRC 0x%02x\n", count, id[0], + id[6], id[5], id[4], id[3], id[2], id[1], id[7]); + count++; + + // continue the search with start argument set to 0 + result = mraa_uart_ow_rom_search(uart, 0, id); + } + + printf("Exiting...\n"); + + mraa_uart_ow_stop(uart); + + return 0; +} +//! [Interesting] diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d41bc7500..a6b45eb28 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -23,6 +23,7 @@ set (mraa_LIB_SRCS_NOAUTO ${PROJECT_SOURCE_DIR}/src/uart/uart.c ${PROJECT_SOURCE_DIR}/src/iio/iio.c ${mraa_LIB_SRCS_NOAUTO} + ${PROJECT_SOURCE_DIR}/src/uart_ow/uart_ow.c ) set (mraa_LIB_X86_SRCS_NOAUTO diff --git a/src/mraa.c b/src/mraa.c index b0bd997e5..0bfbe111a 100644 --- a/src/mraa.c +++ b/src/mraa.c @@ -486,6 +486,15 @@ mraa_result_print(mraa_result_t result) case MRAA_ERROR_PLATFORM_NOT_INITIALISED: fprintf(stdout, "MRAA: Platform not initialised.\n"); break; + case MRAA_ERROR_UART_OW_SHORTED: + fprintf(stdout, "MRAA: UART OW: Bus short detected.\n"); + break; + case MRAA_ERROR_UART_OW_NO_DEVICES: + fprintf(stdout, "MRAA: UART OW: No devices detected on bus.\n"); + break; + case MRAA_ERROR_UART_OW_DATA_ERROR: + fprintf(stdout, "MRAA: UART OW: Data or Bus error detected.\n"); + break; case MRAA_ERROR_UNSPECIFIED: fprintf(stdout, "MRAA: Unspecified Error.\n"); break; diff --git a/src/uart_ow/uart_ow.c b/src/uart_ow/uart_ow.c new file mode 100644 index 000000000..74675c896 --- /dev/null +++ b/src/uart_ow/uart_ow.c @@ -0,0 +1,498 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2016 Intel Corporation + * + * Portions (search) copyright: + * Copyright (C) 2004 Dallas Semiconductor Corporation, All Rights Reserved. + * + * For the crc8 algorithm: + * Copyright (c) 2002 Colin O'Flynn + * + * 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 +#include +#include +#include +#include +#include +#include + +#include "uart.h" +#include "uart_ow.h" +#include "mraa_internal.h" + +// global search state +static unsigned char ROM_NO[8]; /* 8 byte (64b) rom code */ +static int LastDiscrepancy; +static int LastFamilyDiscrepancy; +static mraa_boolean_t LastDeviceFlag; + +// low-level read byte +static unsigned char +read_byte(mraa_uart_ow_context dev) +{ + unsigned char ch = 0; + + while (!mraa_uart_read(dev, &ch, 1)) + ; + + return ch; +} + +// low-level write byte +static void +write_byte(mraa_uart_ow_context dev, const unsigned char ch) +{ + mraa_uart_write(dev, &ch, 1); +} + +// Here we setup a very simple termios with the minimum required +// settings. We use this to also change speed from high to low. We +// use the low speed (9600 bd) for emitting the reset pulse, and +// high speed (115200 bd) for actual data communications. +// +static void +set_speed(mraa_uart_context dev, mraa_boolean_t speed) +{ + + if (!dev) { + syslog(LOG_ERR, "uart_ow: set_speed: context is NULL"); + return; + } + + static speed_t baud; + if (speed) + baud = B115200; + else + baud = B9600; + + struct termios termio = { + .c_cflag = baud | CS8 | CLOCAL | CREAD, .c_iflag = 0, .c_oflag = 0, .c_lflag = NOFLSH, .c_cc = { 0 }, + }; + + tcflush(dev->fd, TCIFLUSH); + + // TCSANOW is required + if (tcsetattr(dev->fd, TCSANOW, &termio) < 0) { + syslog(LOG_ERR, "uart_ow: tcsetattr() failed"); + return; + } + + return; +} + +// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing +// search state. +// Return 1 : device found, ROM number in ROM_NO buffer +// 0 : device not found, end of search +// +static mraa_boolean_t +_ow_search(mraa_uart_ow_context dev) +{ + int id_bit_number; + int last_zero, rom_byte_number, search_result; + int id_bit, cmp_id_bit; + unsigned char rom_byte_mask, search_direction; + + // initialize for search + id_bit_number = 1; + last_zero = 0; + rom_byte_number = 0; + rom_byte_mask = 1; + search_result = 0; + + // if the last call was not the last device + if (!LastDeviceFlag) { + // 1-Wire reset + if (mraa_uart_ow_reset(dev) != MRAA_SUCCESS) { + // reset the search + LastDiscrepancy = 0; + LastDeviceFlag = 0; + LastFamilyDiscrepancy = 0; + return 0; + } + + // issue the search command + mraa_uart_ow_write_byte(dev, MRAA_UART_OW_CMD_SEARCH_ROM); + + // loop to do the search + do { + // read a bit and its complement + id_bit = mraa_uart_ow_bit(dev, 1); + cmp_id_bit = mraa_uart_ow_bit(dev, 1); + + // check for no devices on 1-wire + if ((id_bit == 1) && (cmp_id_bit == 1)) + break; + else { + // all devices coupled have 0 or 1 + if (id_bit != cmp_id_bit) + search_direction = id_bit; // bit write value for search + else { + // if this discrepancy if before the Last Discrepancy + // on a previous next then pick the same as last time + if (id_bit_number < LastDiscrepancy) + search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0); + else + // if equal to last pick 1, if not then pick 0 + search_direction = (id_bit_number == LastDiscrepancy); + // if 0 was picked then record its position in LastZero + if (search_direction == 0) { + last_zero = id_bit_number; + // check for Last discrepancy in family + if (last_zero < 9) + LastFamilyDiscrepancy = last_zero; + } + } + + // set or clear the bit in the ROM byte rom_byte_number + // with mask rom_byte_mask + if (search_direction == 1) + ROM_NO[rom_byte_number] |= rom_byte_mask; + else + ROM_NO[rom_byte_number] &= ~rom_byte_mask; + + // serial number search direction write bit + mraa_uart_ow_bit(dev, search_direction); + + // increment the byte counter id_bit_number + // and shift the mask rom_byte_mask + id_bit_number++; + rom_byte_mask <<= 1; + // if the mask is 0 then go to new SerialNum byte + // rom_byte_number and reset + if (rom_byte_mask == 0) { + rom_byte_number++; + rom_byte_mask = 1; + } + } + } while (rom_byte_number < 8); + + // loop until through all ROM bytes 0-7 + // if the search was successful then + if (id_bit_number >= 65) { + // search successful so set + // LastDiscrepancy,LastDeviceFlag,search_result + LastDiscrepancy = last_zero; + + // check for last device + if (LastDiscrepancy == 0) + LastDeviceFlag = 1; + } + search_result = 1; + } + + // if no device found then reset counters so next 'search' will be + // like a first + if (!search_result || !ROM_NO[0]) { + LastDiscrepancy = 0; + LastDeviceFlag = 0; + LastFamilyDiscrepancy = 0; + search_result = 0; + } + + return search_result; +} + +//-------------------------------------------------------------------------- +// Find the 'first' devices on the 1-Wire bus +// Return 1 : device found, ROM number in ROM_NO buffer +// 0 : no device present +// +static mraa_boolean_t +_ow_first(mraa_uart_ow_context dev) +{ + // reset the search state + LastDiscrepancy = 0; + LastDeviceFlag = 0; + LastFamilyDiscrepancy = 0; + + return _ow_search(dev); +} + +//-------------------------------------------------------------------------- +// Find the 'next' devices on the 1-Wire bus +// Return 1 : device found, ROM number in ROM_NO buffer +// 0 : device not found, end of search +// +static mraa_boolean_t +_ow_next(mraa_uart_ow_context dev) +{ + // leave the search state alone + return _ow_search(dev); +} + +// Start of exported mraa functionality + +mraa_uart_ow_context +mraa_uart_ow_init(int index) +{ + mraa_uart_ow_context dev = mraa_uart_init(index); + + if (!dev) + return NULL; + + // now get the fd, and set it up for non-blocking operation + if (fcntl(dev->fd, F_SETFL, O_NONBLOCK) == -1) { + syslog(LOG_ERR, "uart_ow: failed to set non-blocking on fd"); + mraa_uart_ow_stop(dev); + return NULL; + } + + return dev; +} + +mraa_uart_ow_context +mraa_uart_ow_init_raw(const char* path) +{ + mraa_uart_ow_context dev = mraa_uart_init_raw(path); + + if (!dev) + return NULL; + + // now get the fd, and set it up for non-blocking operation + if (fcntl(dev->fd, F_SETFL, O_NONBLOCK) == -1) { + syslog(LOG_ERR, "uart_ow: failed to set non-blocking on fd"); + mraa_uart_ow_stop(dev); + return NULL; + } + + return dev; +} + +mraa_result_t +mraa_uart_ow_stop(mraa_uart_ow_context dev) +{ + return mraa_uart_stop(dev); +} + +const char* +mraa_uart_ow_get_dev_path(mraa_uart_ow_context dev) +{ + return mraa_uart_get_dev_path(dev); +} + +uint8_t +mraa_uart_ow_bit(mraa_uart_ow_context dev, uint8_t bit) +{ + if (!dev) { + syslog(LOG_ERR, "uart_ow: ow_bit: context is NULL"); + return 0; + } + + if (bit) + write_byte(dev, 0xff); /* write a 1 bit */ + else + write_byte(dev, 0x00); /* write a 0 bit */ + + /* return the bit present on the bus (0xff is a '1', anything else + * (typically 0xfc or 0x00) is a 0 + */ + return (read_byte(dev) == 0xff); +} + +uint8_t +mraa_uart_ow_write_byte(mraa_uart_ow_context dev, uint8_t byte) +{ + if (!dev) { + syslog(LOG_ERR, "uart_ow: write_byte: context is NULL"); + return 0; + } + + /* writing bytes - each bit on the byte to send corresponds to a + * byte on the uart. At the same time, we read bits (uart bytes) + * from the bus and build a byte to return. This is possible due to + * the way we wire the UART TX/RX pins together, similar to a + * loopback connection, except the devices on the 1-wire bus have + * the ability to modify the returning bitstream. + */ + + uint8_t bit; + int i; + for (i = 0; i < 8; i++) { + bit = mraa_uart_ow_bit(dev, byte & 0x01); + /* prep for next bit to send, and clear space for bit read */ + byte >>= 1; + /* store read bit in the msb */ + if (bit) + byte |= 0x80; + } + + /* return the new byte read */ + return byte; +} + +uint8_t +mraa_uart_ow_read_byte(mraa_uart_ow_context dev) +{ + if (!dev) { + syslog(LOG_ERR, "uart_ow: read_byte: context is NULL"); + return 0; + } + + /* we read by sending 0xff, so the bus is released on the initial + * low pulse (uart start bit) for every timeslot, when the device + * will then send it's bits + */ + return mraa_uart_ow_write_byte(dev, 0xff); +} + +mraa_result_t +mraa_uart_ow_reset(mraa_uart_ow_context dev) +{ + if (!dev) { + syslog(LOG_ERR, "uart_ow: reset: context is NULL"); + return MRAA_ERROR_INVALID_HANDLE; + } + + uint8_t rv; + + /* To emit a proper reset pulse, we set low speed (9600 baud) for + * the reset pulse and send 0xf0 to pull the line down for the + * minimum amount of time. + * + * From the Maxim whitepaper: + * + * Transmitting an 0xF0 from the UART forms a proper Reset + * pulse. The receive value depends on whether one or more 1-Wire + * slave devices are present, their internal timing of each slave + * device present, and the UART's detection timing within each bit + * window. If no device is present, the receive value will equal the + * transmit value. Otherwise the receive value can vary. + */ + set_speed(dev, 0); + /* pull the data line low */ + write_byte(dev, 0xf0); + + rv = read_byte(dev); + + /* back up to high speed for normal data transmissions */ + set_speed(dev, 1); + + /* shorted data line */ + if (rv == 0x00) + return MRAA_ERROR_UART_OW_SHORTED; + + /* no devices detected (no presence pulse) */ + if (rv == 0xf0) + return MRAA_ERROR_UART_OW_NO_DEVICES; + + /* otherwise, at least one device is present */ + return MRAA_SUCCESS; +} + + +mraa_result_t +mraa_uart_ow_rom_search(mraa_uart_ow_context dev, mraa_boolean_t start, uint8_t* id) +{ + if (!dev) { + syslog(LOG_ERR, "uart_ow: rom_search: context is NULL"); + return MRAA_ERROR_INVALID_HANDLE; + } + + // bail if there aren't any devices, or some other error occurs + mraa_result_t rv; + if ((rv = mraa_uart_ow_reset(dev)) != MRAA_SUCCESS) + return rv; + + mraa_boolean_t result; + + // see if we are starting from scratch + if (start) + result = _ow_first(dev); + else + result = _ow_next(dev); + + if (result) { + // found one. Copy into id and return 1 + int i; + for (i = 0; i < MRAA_UART_OW_ROMCODE_SIZE; i++) + id[i] = ROM_NO[i]; + + return MRAA_SUCCESS; + } else + return MRAA_ERROR_UART_OW_NO_DEVICES; +} + +mraa_result_t +mraa_uart_ow_command(mraa_uart_ow_context dev, uint8_t command, uint8_t* id) +{ + if (!dev) { + syslog(LOG_ERR, "uart_ow: ow_command: context is NULL"); + return MRAA_ERROR_INVALID_HANDLE; + } + + /* send reset pulse first */ + mraa_result_t rv = mraa_uart_ow_reset(dev); + + if (rv != MRAA_SUCCESS) + return rv; + + if (id) { + /* send the match rom command */ + mraa_uart_ow_write_byte(dev, MRAA_UART_OW_CMD_MATCH_ROM); + + /* sending to a specific device, so send out the full romcode */ + int i; + for (i = 0; i < MRAA_UART_OW_ROMCODE_SIZE; i++) + mraa_uart_ow_write_byte(dev, id[i]); + } else { + /* send to all devices (or a single device if it's the only one + * on the bus) + */ + mraa_uart_ow_write_byte(dev, MRAA_UART_OW_CMD_SKIP_ROM); + } + + mraa_uart_ow_write_byte(dev, command); + + return MRAA_SUCCESS; +} + +uint8_t +mraa_uart_ow_crc8(uint8_t* buffer, uint16_t length) +{ + // 0x18 = X ^ 8 + X ^ 5 + X ^ 4 + X ^ 0 + static const uint8_t CRC8POLY = 0x18; + + uint8_t crc = 0x00; + uint16_t loop_count; + uint8_t bit_counter; + uint8_t data; + uint8_t feedback_bit; + + for (loop_count = 0; loop_count != length; loop_count++) { + data = buffer[loop_count]; + bit_counter = 8; + do { + feedback_bit = (crc ^ data) & 0x01; + if (feedback_bit == 0x01) + crc = crc ^ CRC8POLY; + crc = (crc >> 1) & 0x7F; + if (feedback_bit == 0x01) + crc = crc | 0x80; + data = data >> 1; + bit_counter--; + } while (bit_counter > 0); + } + + return crc; +}