| /* |
| * Author: Jon Trulson <jtrulson@ics.com> |
| * 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 <stdlib.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #include <string.h> |
| #include <termios.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| |
| #include "uart.h" |
| #include "uart_ow.h" |
| #include "mraa_internal.h" |
| |
| // low-level read byte |
| static mraa_result_t |
| _ow_read_byte(mraa_uart_ow_context dev, uint8_t *ch) |
| { |
| while (!mraa_uart_read(dev->uart, (char*) ch, 1)) |
| ; |
| |
| return MRAA_SUCCESS; |
| } |
| |
| // low-level write byte |
| static int |
| _ow_write_byte(mraa_uart_ow_context dev, const char ch) |
| { |
| return mraa_uart_write(dev->uart, &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 mraa_result_t |
| _ow_set_speed(mraa_uart_ow_context dev, mraa_boolean_t speed) |
| { |
| |
| if (!dev) { |
| syslog(LOG_ERR, "uart_ow: set_speed: context is NULL"); |
| return MRAA_ERROR_INVALID_HANDLE; |
| } |
| |
| 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->uart->fd, TCIFLUSH); |
| |
| // TCSANOW is required |
| if (tcsetattr(dev->uart->fd, TCSANOW, &termio) < 0) { |
| syslog(LOG_ERR, "uart_ow: tcsetattr() failed"); |
| return MRAA_ERROR_INVALID_RESOURCE; |
| } |
| |
| return MRAA_SUCCESS; |
| } |
| |
| // 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 (!dev->LastDeviceFlag) { |
| // 1-Wire reset |
| if (mraa_uart_ow_reset(dev) != MRAA_SUCCESS) { |
| // reset the search |
| dev->LastDiscrepancy = 0; |
| dev->LastDeviceFlag = 0; |
| dev->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 < dev->LastDiscrepancy) |
| search_direction = ((dev->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 == dev->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) |
| dev->LastFamilyDiscrepancy = last_zero; |
| } |
| } |
| |
| // set or clear the bit in the ROM byte rom_byte_number |
| // with mask rom_byte_mask |
| if (search_direction == 1) |
| dev->ROM_NO[rom_byte_number] |= rom_byte_mask; |
| else |
| dev->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 |
| dev->LastDiscrepancy = last_zero; |
| |
| // check for last device |
| if (dev->LastDiscrepancy == 0) |
| dev->LastDeviceFlag = 1; |
| } |
| search_result = 1; |
| } |
| |
| // if no device found then reset counters so next 'search' will be |
| // like a first |
| if (!search_result || !dev->ROM_NO[0]) { |
| dev->LastDiscrepancy = 0; |
| dev->LastDeviceFlag = 0; |
| dev->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 |
| dev->LastDiscrepancy = 0; |
| dev->LastDeviceFlag = 0; |
| dev->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 = calloc(1, sizeof(struct _mraa_uart_ow)); |
| if (!dev) |
| return NULL; |
| |
| dev->uart = mraa_uart_init(index); |
| if (!dev->uart) |
| { |
| free(dev); |
| return NULL; |
| } |
| |
| |
| // now get the fd, and set it up for non-blocking operation |
| if (fcntl(dev->uart->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 = calloc(1, sizeof(struct _mraa_uart_ow)); |
| if (!dev) |
| return NULL; |
| |
| dev->uart = mraa_uart_init_raw(path); |
| if (!dev->uart) |
| { |
| free(dev); |
| return NULL; |
| } |
| |
| // now get the fd, and set it up for non-blocking operation |
| if (fcntl(dev->uart->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) |
| { |
| mraa_result_t rv = mraa_uart_stop(dev->uart); |
| free(dev); |
| return rv; |
| } |
| |
| const char* |
| mraa_uart_ow_get_dev_path(mraa_uart_ow_context dev) |
| { |
| return mraa_uart_get_dev_path(dev->uart); |
| } |
| |
| int |
| 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 -1; |
| } |
| |
| int ret = 0; |
| uint8_t ch; |
| if (bit) { |
| ret = _ow_write_byte(dev, 0xff); /* write a 1 bit */ |
| } |
| else { |
| ret = _ow_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 |
| */ |
| if (_ow_read_byte(dev, &ch) == -1 || ret == -1) { |
| return -1; |
| } |
| return (ch == 0xff); |
| } |
| |
| int |
| 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 -1; |
| } |
| |
| /* 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; |
| } |
| |
| int |
| mraa_uart_ow_read_byte(mraa_uart_ow_context dev) |
| { |
| if (!dev) { |
| syslog(LOG_ERR, "uart_ow: read_byte: context is NULL"); |
| return -1; |
| } |
| |
| /* 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. |
| */ |
| if (_ow_set_speed(dev, 0) != MRAA_SUCCESS) { |
| return MRAA_ERROR_INVALID_HANDLE; |
| } |
| |
| /* pull the data line low */ |
| _ow_write_byte(dev, 0xf0); |
| |
| _ow_read_byte(dev, &rv); |
| |
| /* back up to high speed for normal data transmissions */ |
| if (_ow_set_speed(dev, 1) != MRAA_SUCCESS) { |
| return MRAA_ERROR_INVALID_HANDLE; |
| } |
| |
| /* 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] = dev->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; |
| } |
